module.exports =
/******/ (function(modules) { // webpackBootstrap
/******/ 	// The module cache
/******/ 	var installedModules = {};
/******/
/******/ 	// The require function
/******/ 	function __webpack_require__(moduleId) {
/******/
/******/ 		// Check if module is in cache
/******/ 		if(installedModules[moduleId]) {
/******/ 			return installedModules[moduleId].exports;
/******/ 		}
/******/ 		// Create a new module (and put it into the cache)
/******/ 		var module = installedModules[moduleId] = {
/******/ 			i: moduleId,
/******/ 			l: false,
/******/ 			exports: {}
/******/ 		};
/******/
/******/ 		// Execute the module function
/******/ 		modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
/******/
/******/ 		// Flag the module as loaded
/******/ 		module.l = true;
/******/
/******/ 		// Return the exports of the module
/******/ 		return module.exports;
/******/ 	}
/******/
/******/
/******/ 	// expose the modules object (__webpack_modules__)
/******/ 	__webpack_require__.m = modules;
/******/
/******/ 	// expose the module cache
/******/ 	__webpack_require__.c = installedModules;
/******/
/******/ 	// define getter function for harmony exports
/******/ 	__webpack_require__.d = function(exports, name, getter) {
/******/ 		if(!__webpack_require__.o(exports, name)) {
/******/ 			Object.defineProperty(exports, name, { enumerable: true, get: getter });
/******/ 		}
/******/ 	};
/******/
/******/ 	// define __esModule on exports
/******/ 	__webpack_require__.r = function(exports) {
/******/ 		if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
/******/ 			Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
/******/ 		}
/******/ 		Object.defineProperty(exports, '__esModule', { value: true });
/******/ 	};
/******/
/******/ 	// create a fake namespace object
/******/ 	// mode & 1: value is a module id, require it
/******/ 	// mode & 2: merge all properties of value into the ns
/******/ 	// mode & 4: return value when already ns object
/******/ 	// mode & 8|1: behave like require
/******/ 	__webpack_require__.t = function(value, mode) {
/******/ 		if(mode & 1) value = __webpack_require__(value);
/******/ 		if(mode & 8) return value;
/******/ 		if((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;
/******/ 		var ns = Object.create(null);
/******/ 		__webpack_require__.r(ns);
/******/ 		Object.defineProperty(ns, 'default', { enumerable: true, value: value });
/******/ 		if(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));
/******/ 		return ns;
/******/ 	};
/******/
/******/ 	// getDefaultExport function for compatibility with non-harmony modules
/******/ 	__webpack_require__.n = function(module) {
/******/ 		var getter = module && module.__esModule ?
/******/ 			function getDefault() { return module['default']; } :
/******/ 			function getModuleExports() { return module; };
/******/ 		__webpack_require__.d(getter, 'a', getter);
/******/ 		return getter;
/******/ 	};
/******/
/******/ 	// Object.prototype.hasOwnProperty.call
/******/ 	__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
/******/
/******/ 	// __webpack_public_path__
/******/ 	__webpack_require__.p = "/dist/";
/******/
/******/
/******/ 	// Load entry module and return exports
/******/ 	return __webpack_require__(__webpack_require__.s = 83);
/******/ })
/************************************************************************/
/******/ ([
/* 0 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return normalizeComponent; });
/* globals __VUE_SSR_CONTEXT__ */

// IMPORTANT: Do NOT use ES2015 features in this file (except for modules).
// This module is a runtime utility for cleaner component module output and will
// be included in the final webpack user bundle.

function normalizeComponent (
  scriptExports,
  render,
  staticRenderFns,
  functionalTemplate,
  injectStyles,
  scopeId,
  moduleIdentifier, /* server only */
  shadowMode /* vue-cli only */
) {
  // Vue.extend constructor export interop
  var options = typeof scriptExports === 'function'
    ? scriptExports.options
    : scriptExports

  // render functions
  if (render) {
    options.render = render
    options.staticRenderFns = staticRenderFns
    options._compiled = true
  }

  // functional template
  if (functionalTemplate) {
    options.functional = true
  }

  // scopedId
  if (scopeId) {
    options._scopeId = 'data-v-' + scopeId
  }

  var hook
  if (moduleIdentifier) { // server build
    hook = function (context) {
      // 2.3 injection
      context =
        context || // cached call
        (this.$vnode && this.$vnode.ssrContext) || // stateful
        (this.parent && this.parent.$vnode && this.parent.$vnode.ssrContext) // functional
      // 2.2 with runInNewContext: true
      if (!context && typeof __VUE_SSR_CONTEXT__ !== 'undefined') {
        context = __VUE_SSR_CONTEXT__
      }
      // inject component styles
      if (injectStyles) {
        injectStyles.call(this, context)
      }
      // register component module identifier for async chunk inferrence
      if (context && context._registeredComponents) {
        context._registeredComponents.add(moduleIdentifier)
      }
    }
    // used by ssr in case component is cached and beforeCreate
    // never gets called
    options._ssrRegister = hook
  } else if (injectStyles) {
    hook = shadowMode
      ? function () {
        injectStyles.call(
          this,
          (options.functional ? this.parent : this).$root.$options.shadowRoot
        )
      }
      : injectStyles
  }

  if (hook) {
    if (options.functional) {
      // for template-only hot-reload because in that case the render fn doesn't
      // go through the normalizer
      options._injectStyles = hook
      // register for functional component in vue file
      var originalRender = options.render
      options.render = function renderWithStyleInjection (h, context) {
        hook.call(context)
        return originalRender(h, context)
      }
    } else {
      // inject component registration as beforeCreate hook
      var existing = options.beforeCreate
      options.beforeCreate = existing
        ? [].concat(existing, hook)
        : [hook]
    }
  }

  return {
    exports: scriptExports,
    options: options
  }
}


/***/ }),
/* 1 */,
/* 2 */
/***/ (function(module, exports) {

module.exports = require("forever-zu/lib/utils/dom");

/***/ }),
/* 3 */
/***/ (function(module, exports) {

module.exports = require("forever-zu/lib/utils/util");

/***/ }),
/* 4 */
/***/ (function(module, exports) {

module.exports = require("forever-zu/lib/mixins/emitter");

/***/ }),
/* 5 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "b", function() { return hasProperty; });
var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };

var is = {
  type: function type(arg, _type) {
    return Object.prototype.toString.call(arg) === '[object ' + _type + ']';
  },
  Undef: function Undef(v) {
    return v === undefined || v === null;
  },
  Element: function Element(arg) {
    return (typeof arg === 'undefined' ? 'undefined' : _typeof(arg)) === 'object' && arg !== null && arg.nodeType === 1 && !is.Object(arg);
  },
  trueArray: function trueArray(data) {
    return Array.isArray(data) && data.length > 0;
  }
};

['Date', 'Object', 'Function', 'String', 'Boolean', ' Array', 'Number'].forEach(function (t) {
  is[t] = function (arg) {
    return is.type(arg, t);
  };
});

function hasProperty(rule, k) {
  return {}.hasOwnProperty.call(rule, k);
}

/* harmony default export */ __webpack_exports__["a"] = (is);

/***/ }),
/* 6 */
/***/ (function(module, exports) {

module.exports = require("forever-zu/lib/utils/vue-popper");

/***/ }),
/* 7 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return extend; });
/* unused harmony export copy */
/* harmony import */ var _modify__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(30);
var _extends2 = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };

var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };

/* eslint-disable no-sequences */


var _extends = Object.assign || function (a) {
  for (var b, c = 1; c < arguments.length; c++) {
    for (var d in b = arguments[c], b) {
      Object.prototype.hasOwnProperty.call(b, d) && Object(_modify__WEBPACK_IMPORTED_MODULE_0__[/* $set */ "b"])(a, d, b[d]);
    }
  }

  return a;
};

function extend() {
  return _extends.apply(this, arguments);
}

function copy(obj) {
  if ((typeof obj === 'undefined' ? 'undefined' : _typeof(obj)) !== 'object' || obj === null) return obj;
  return obj instanceof Array ? [].concat(obj) : _extends2({}, obj);
}

/***/ }),
/* 8 */
/***/ (function(module, exports) {

module.exports = require("forever-zu/lib/mixins/locale");

/***/ }),
/* 9 */
/***/ (function(module, exports) {

module.exports = require("vue");

/***/ }),
/* 10 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "l", function() { return toJson; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "j", function() { return parseFn; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "k", function() { return parseJson; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "d", function() { return enumerable; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "b", function() { return copyRule; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "c", function() { return copyRules; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "i", function() { return mergeRule; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "f", function() { return getRule; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "h", function() { return mergeGlobal; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "e", function() { return funcProxy; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return byCtx; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "g", function() { return invoke; });
/* harmony import */ var packages_form_create_utils_deepextend__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(28);
/* harmony import */ var packages_form_create_utils_type__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(5);
/* harmony import */ var packages_form_create_utils_mergeprops__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(23);
/* harmony import */ var _attrs__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(34);
/* harmony import */ var packages_form_create_utils_console__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(29);
var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };

/* eslint-disable no-eval */






var PREFIX = '[[FORM-CREATE-PREFIX-';
var SUFFIX = '-FORM-CREATE-SUFFIX]]';

var $T = '$FN:';
var FUNCTION = 'function';

function toJson(obj, space) {
  return JSON.stringify(Object(packages_form_create_utils_deepextend__WEBPACK_IMPORTED_MODULE_0__[/* default */ "b"])([], obj, true), function (key, val) {
    if (val && val._isVue === true) return undefined;

    if ((typeof val === 'undefined' ? 'undefined' : _typeof(val)) !== FUNCTION) {
      return val;
    }
    if (val.__inject) val = val.__origin;

    if (val.__emit) return undefined;

    return PREFIX + val + SUFFIX;
  }, space);
}

function makeFn(fn) {
  return eval('(' + FUNCTION + '(){return ' + fn + ' })()');
}

function parseFn(fn, mode) {
  if (fn && packages_form_create_utils_type__WEBPACK_IMPORTED_MODULE_1__[/* default */ "a"].String(fn)) {
    var v = fn.trim();
    var flag = false;
    if (v.indexOf(SUFFIX) > 0 && v.indexOf(PREFIX) === 0) {
      v = v.replace(SUFFIX, '').replace(PREFIX, '');
      flag = true;
    } else if (v.indexOf($T) === 0) {
      v = v.replace($T, '');
      flag = true;
    } else if (!mode && v.indexOf(FUNCTION) === 0 && v !== FUNCTION) {
      flag = true;
    }
    if (!flag) return fn;
    try {
      return makeFn(v.indexOf(FUNCTION) === -1 && v.indexOf('(') !== 0 ? FUNCTION + ' ' + v : v);
    } catch (e) {
      Object(packages_form_create_utils_console__WEBPACK_IMPORTED_MODULE_4__[/* err */ "a"])('\u89E3\u6790\u5931\u8D25:' + v);
      return undefined;
    }
  }
  return fn;
}

function parseJson(json, mode) {
  return JSON.parse(json, function (k, v) {
    if (packages_form_create_utils_type__WEBPACK_IMPORTED_MODULE_1__[/* default */ "a"].Undef(v) || !v.indexOf) return v;
    return parseFn(v, mode);
  });
}

function enumerable(value, writable) {
  return {
    value: value,
    enumerable: false,
    configurable: false,
    writable: !!writable
  };
}

// todo 优化位置
function copyRule(rule, mode) {
  return copyRules([rule], mode || false)[0];
}

function copyRules(rules, mode) {
  return Object(packages_form_create_utils_deepextend__WEBPACK_IMPORTED_MODULE_0__[/* default */ "b"])([], [].concat(rules), mode || false);
}

function mergeRule(rule, merge) {
  Object(packages_form_create_utils_mergeprops__WEBPACK_IMPORTED_MODULE_2__[/* default */ "a"])(Array.isArray(merge) ? merge : [merge], rule, {
    array: _attrs__WEBPACK_IMPORTED_MODULE_3__[/* arrayAttrs */ "a"],
    normal: _attrs__WEBPACK_IMPORTED_MODULE_3__[/* normalAttrs */ "d"]
  });
  return rule;
}

function getRule(rule) {
  return packages_form_create_utils_type__WEBPACK_IMPORTED_MODULE_1__[/* default */ "a"].Function(rule.getRule) ? rule.getRule() : rule;
}

function mergeGlobal(target, merge) {
  if (!target) return merge;
  Object.keys(merge || {}).forEach(function (k) {
    if (merge[k]) {
      target[k] = mergeRule(target[k] || {}, merge[k]);
    }
  });
  return target;
}

function funcProxy(that, proxy) {
  Object.defineProperties(that, Object.keys(proxy).reduce(function (initial, k) {
    initial[k] = {
      get: function get() {
        return proxy[k]();
      }
    };
    return initial;
  }, {}));
}

function byCtx(rule) {
  return rule.__fc__ || (rule.__origin__ ? rule.__origin__.__fc__ : null);
}

function invoke(fn, def) {
  try {
    def = fn();
  } catch (e) {
    Object(packages_form_create_utils_console__WEBPACK_IMPORTED_MODULE_4__[/* logError */ "c"])(e);
  }
  return def;
}

/***/ }),
/* 11 */,
/* 12 */
/***/ (function(module, exports) {

module.exports = require("forever-zu/lib/utils/merge");

/***/ }),
/* 13 */
/***/ (function(module, exports) {

module.exports = require("forever-zu/lib/input");

/***/ }),
/* 14 */
/***/ (function(module, exports) {

module.exports = require("forever-zu/lib/mixins/migrating");

/***/ }),
/* 15 */
/***/ (function(module, exports) {

module.exports = require("forever-zu/lib/utils/clickoutside");

/***/ }),
/* 16 */
/***/ (function(module, exports) {

module.exports = require("forever-zu/lib/utils/resize-event");

/***/ }),
/* 17 */
/***/ (function(module, exports) {

module.exports = require("forever-zu/lib/scrollbar");

/***/ }),
/* 18 */,
/* 19 */
/***/ (function(module, exports) {

module.exports = require("throttle-debounce/debounce");

/***/ }),
/* 20 */,
/* 21 */
/***/ (function(module, exports) {

module.exports = require("forever-zu/lib/checkbox");

/***/ }),
/* 22 */
/***/ (function(module, exports) {

module.exports = require("babel-helper-vue-jsx-merge-props");

/***/ }),
/* 23 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "c", function() { return normalMerge; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "d", function() { return toArrayMerge; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "b", function() { return functionalMerge; });
var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };

var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };

var normalMerge = ['attrs', 'props', 'domProps', 'scopedSlots'];
var toArrayMerge = ['class', 'style', 'directives'];
var functionalMerge = ['on', 'nativeOn'];

var mergeProps = function mergeProps(objects) {
  var initial = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
  var opt = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};

  var _normalMerge = [].concat(normalMerge, opt['normal'] || []);
  var _toArrayMerge = [].concat(toArrayMerge, opt['array'] || []);
  var _functionalMerge = [].concat(functionalMerge, opt['functional'] || []);
  var propsMerge = opt['props'] || [];

  return objects.reduce(function (a, b) {
    for (var key in b) {
      if (a[key]) {
        if (propsMerge.indexOf(key) > -1) {
          a[key] = mergeProps([b[key]], a[key]);
        } else if (_normalMerge.indexOf(key) > -1) {
          a[key] = _extends({}, a[key], b[key]);
        } else if (_toArrayMerge.indexOf(key) > -1) {
          var arrA = a[key] instanceof Array ? a[key] : [a[key]];
          var arrB = b[key] instanceof Array ? b[key] : [b[key]];
          a[key] = [].concat(arrA, arrB);
        } else if (_functionalMerge.indexOf(key) > -1) {
          for (var event in b[key]) {
            if (a[key][event]) {
              var _arrA = a[key][event] instanceof Array ? a[key][event] : [a[key][event]];
              var _arrB = b[key][event] instanceof Array ? b[key][event] : [b[key][event]];
              a[key][event] = [].concat(_arrA, _arrB);
            } else {
              a[key][event] = b[key][event];
            }
          }
        } else if (key === 'hook') {
          for (var hook in b[key]) {
            if (a[key][hook]) {
              a[key][hook] = mergeFn(a[key][hook], b[key][hook]);
            } else {
              a[key][hook] = b[key][hook];
            }
          }
        } else {
          a[key] = b[key];
        }
      } else {
        if (_normalMerge.indexOf(key) > -1 || _functionalMerge.indexOf(key) > -1 || propsMerge.indexOf(key) > -1) {
          a[key] = _extends({}, b[key]);
        } else if (_toArrayMerge.indexOf(key) > -1) {
          a[key] = b[key] instanceof Array ? [].concat(b[key]) : _typeof(b[key]) === 'object' ? _extends({}, b[key]) : b[key];
        } else {
          a[key] = b[key];
        }
      }
    }
    return a;
  }, initial);
};

var mergeFn = function mergeFn(fn1, fn2) {
  return function () {
    fn1 && fn1.apply(this, arguments);
    fn2 && fn2.apply(this, arguments);
  };
};

/* harmony default export */ __webpack_exports__["a"] = (mergeProps);

/***/ }),
/* 24 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";

// EXPORTS
__webpack_require__.d(__webpack_exports__, "a", function() { return /* reexport */ creatorFactory; });

// UNUSED EXPORTS: Creator, Manager, parseJson, toJson, copyRule, copyRules, mergeRule

// EXTERNAL MODULE: ./packages/form-create/utils/extend.js
var extend = __webpack_require__(7);

// CONCATENATED MODULE: ./packages/form-create/coreSrc/components/formCreate.js


var NAME = 'ElFormCreate';

function $FormCreate(FormCreate) {
  return {
    name: NAME,
    componentName: NAME,
    model: {
      prop: 'api'
    },
    provide: function provide() {
      return {
        $pfc: this
      };
    },

    inject: { $pfc: { default: null } },
    props: {
      rule: {
        type: Array,
        required: true
      },
      option: {
        type: Object,
        default: function _default() {
          return {};
        }
      },
      extendOption: Boolean,
      value: Object,
      api: Object
    },
    data: function data() {
      return {
        formData: undefined,
        destroyed: false,
        validate: {},
        $f: undefined,
        isShow: true,
        unique: 1,
        renderRule: [].concat(this.rule || []),
        updateValue: ''
      };
    },
    render: function render() {
      return this.formCreate.render();
    },

    methods: {
      _refresh: function _refresh() {
        ++this.unique;
      },
      _renderRule: function _renderRule() {
        this.renderRule = [].concat(this.rule || []);
      },
      _updateValue: function _updateValue(value) {
        if (this.destroyed) return;
        this.updateValue = JSON.stringify(value);
        this.$emit('update:value', value);
      }
    },
    watch: {
      value: {
        handler: function handler(n) {
          if (JSON.stringify(n) === this.updateValue) return;
          this.$f.setValue(n);
        },

        deep: true
      },
      option: {
        handler: function handler(n) {
          this.formCreate.initOptions(n);
          this.$f.refresh();
        },

        deep: true
      },
      rule: function rule(n) {
        var _this = this;

        if (n.length === this.renderRule.length && n.every(function (v) {
          return _this.renderRule.indexOf(v) > -1;
        })) {
          return;
        }
        this.formCreate.$handle.reloadRule(n);
        this._renderRule();
      }
    },
    beforeCreate: function beforeCreate() {
      var _this2 = this;

      var _$options$propsData = this.$options.propsData,
          rule = _$options$propsData.rule,
          option = _$options$propsData.option,
          value = _$options$propsData.value;

      this.formCreate = new FormCreate(this, rule, option);
      Object(extend["a" /* default */])(this.formCreate.options.formData, value || {});
      Object.keys(this.formCreate.prop).forEach(function (k) {
        Object(extend["a" /* default */])(_this2.$options[k], _this2.formCreate.prop[k]);
      });
    }
  };
}
// EXTERNAL MODULE: external "vue"
var external_vue_ = __webpack_require__(9);
var external_vue_default = /*#__PURE__*/__webpack_require__.n(external_vue_);

// EXTERNAL MODULE: ./packages/form-create/utils/type.js
var utils_type = __webpack_require__(5);

// EXTERNAL MODULE: ./packages/form-create/coreSrc/frame/attrs.js
var frame_attrs = __webpack_require__(34);

// EXTERNAL MODULE: ./packages/form-create/coreSrc/frame/util.js
var util = __webpack_require__(10);

// CONCATENATED MODULE: ./packages/form-create/utils/debounce.js
function debounce(fn, wait) {
  var timeout = null;
  return function () {
    var _this = this;

    for (var _len = arguments.length, arg = Array(_len), _key = 0; _key < _len; _key++) {
      arg[_key] = arguments[_key];
    }

    if (timeout !== null) {
      clearTimeout(timeout);
    }
    timeout = setTimeout(function () {
      return fn.call.apply(fn, [_this].concat(arg));
    }, wait);
  };
}
// EXTERNAL MODULE: ./packages/form-create/utils/toarray.js
var toarray = __webpack_require__(32);

// EXTERNAL MODULE: ./packages/form-create/utils/tostring.js
var tostring = __webpack_require__(49);

// CONCATENATED MODULE: ./packages/form-create/utils/toline.js
function toLine(name) {
  var line = name.replace(/([A-Z])/g, '-$1').toLocaleLowerCase();
  if (line.indexOf('-') === 0) {
    line = line.substr(1);
  }
  return line;
}
// CONCATENATED MODULE: ./packages/form-create/utils/todate.js


function toDate(timeStamp) {
  if (utils_type["a" /* default */].Date(timeStamp)) {
    return timeStamp;
  } else {
    var date = new Date(timeStamp);
    return date.toString() === 'Invalid Date' ? timeStamp : date;
  }
}
// EXTERNAL MODULE: ./packages/form-create/utils/deepextend.js
var deepextend = __webpack_require__(28);

// EXTERNAL MODULE: ./packages/form-create/utils/json.js
var json = __webpack_require__(62);

// EXTERNAL MODULE: ./packages/form-create/utils/modify.js
var modify = __webpack_require__(30);

// CONCATENATED MODULE: ./packages/form-create/utils/unique.js
var unique_id = 0;

function uniqueId() {
  return Math.random().toString(36).substr(3, 3) + Number("" + Date.now() + ++unique_id).toString(36);
}
// EXTERNAL MODULE: ./packages/form-create/utils/slot.js
var slot = __webpack_require__(39);

// CONCATENATED MODULE: ./packages/form-create/utils/index.js












// CONCATENATED MODULE: ./packages/form-create/coreSrc/factory/creator.js





function baseRule() {
  return {
    props: {},
    on: {},
    options: [],
    children: [],
    hidden: false,
    display: true,
    value: undefined
  };
}

function creatorFactory(name, init) {
  return function (title, field, value) {
    var props = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};

    var maker = new Creator(name, title, field, value, props);
    if (init) {
      if (utils_type["a" /* default */].Function(init)) init(maker);else maker.props(init);
    }
    return maker;
  };
}

function Creator(type, title, field, value, props) {
  this._data = Object(extend["a" /* default */])(baseRule(), {
    type: type,
    title: title,
    field: field,
    value: value,
    props: props || {}
  });
  this.event = this.on;
}

Object(extend["a" /* default */])(Creator.prototype, {
  getRule: function getRule() {
    return this._data;
  },
  setProp: function setProp(key, value) {
    Object(modify["b" /* $set */])(this._data, key, value);
    return this;
  },
  _clone: function _clone() {
    var clone = new this.constructor();
    clone._data = Object(util["b" /* copyRule */])(this._data);
    return clone;
  }
});

function appendProto(attrs) {
  attrs.forEach(function (name) {
    Creator.prototype[name] = function (key) {
      var _ref, _mergeRule;

      Object(util["i" /* mergeRule */])(this._data, (_mergeRule = {}, _mergeRule[name] = arguments.length < 2 ? key : (_ref = {}, _ref[key] = arguments[1], _ref), _mergeRule));
      return this;
    };
  });
}

appendProto(Object(frame_attrs["b" /* attrs */])());
// CONCATENATED MODULE: ./packages/form-create/coreSrc/factory/maker.js


var commonMaker = creatorFactory('');

function maker_create(type, field, title) {
  var make = commonMaker('', field);
  make._data.type = type;
  make._data.title = title;
  return make;
}

function createTmp(template, vm, field, title) {
  var make = commonMaker('', field);
  make._data.type = 'template';
  make._data.template = template;
  make._data.title = title;
  make._data.vm = vm;
  return make;
}

function makerFactory() {
  return {
    create: maker_create,
    createTmp: createTmp,
    template: createTmp,
    factory: creatorFactory
  };
}
// EXTERNAL MODULE: ./packages/form-create/utils/console.js
var console = __webpack_require__(29);

// CONCATENATED MODULE: ./packages/form-create/coreSrc/frame/api.js







function copy(value) {
  return Object(deepextend["a" /* deepCopy */])(value);
}

function byRules(ctxs, origin) {
  return Object.keys(ctxs).reduce(function (initial, key) {
    initial[key] = origin ? ctxs[key].origin : ctxs[key].rule;
    return initial;
  }, {});
}

function Api(h) {
  function tidyFields(fields) {
    if (utils_type["a" /* default */].Undef(fields)) fields = h.fields();else if (!Array.isArray(fields)) fields = [fields];
    return fields;
  }

  function props(fields, key, val) {
    tidyFields(fields).forEach(function (field) {
      var ctx = h.getCtx(field);
      if (!ctx) return;
      Object(modify["b" /* $set */])(ctx.rule, key, val);
      h.$render.clearCache(ctx);
    });
  }

  function allSubForm() {
    var subs = h.subForm;
    return Object.keys(subs).reduce(function (initial, k) {
      var sub = subs[k];
      if (!sub) return initial;
      if (Array.isArray(sub)) initial.push.apply(initial, sub);else initial.push(sub);
      return initial;
    }, []);
  }

  var api = {
    helper: {
      tidyFields: tidyFields,
      props: props
    },
    get config() {
      return h.options;
    },
    get options() {
      return h.options;
    },
    get form() {
      return h.form;
    },
    get rule() {
      return h.rules;
    },
    get parent() {
      return h.vm.$pfc && h.vm.$pfc.$f;
    },
    get children() {
      return allSubForm();
    },
    formData: function formData(fields) {
      return tidyFields(fields).reduce(function (initial, id) {
        var ctx = h.fieldCtx[id];
        if (!ctx) return initial;
        initial[ctx.field] = copy(ctx.rule.value);
        return initial;
      }, {});
    },
    getValue: function getValue(field) {
      var ctx = h.fieldCtx[field];
      if (!ctx) return;
      return copy(ctx.rule.value);
    },
    coverValue: function coverValue(formData) {
      h.deferSyncValue(function () {
        Object.keys(h.fieldCtx).forEach(function (key) {
          var ctx = h.fieldCtx[key];
          if (!ctx) return h.appendData[key] = formData[key];
          ctx.rule.value = Object(utils_type["b" /* hasProperty */])(formData, key) ? formData[key] : undefined;
        });
      });
    },
    setValue: function setValue(field) {
      var _formData;

      var formData = field;
      if (arguments.length >= 2) formData = (_formData = {}, _formData[field] = arguments[1], _formData);
      h.deferSyncValue(function () {
        Object.keys(formData).forEach(function (key) {
          var ctx = h.fieldCtx[key];
          if (!ctx) return h.appendData[key] = formData[key];
          ctx.rule.value = formData[key];
        });
      });
    },
    removeField: function removeField(field) {
      var ctx = h.getCtx(field);
      if (!ctx) return;
      ctx.rm();
      return ctx.origin;
    },
    removeRule: function removeRule(rule) {
      var ctx = rule && Object(util["a" /* byCtx */])(rule);
      if (!ctx) return;
      ctx.rm();
      return ctx.origin;
    },

    destroy: function destroy() {
      h.vm.$el.parentNode && h.vm.$el.parentNode.removeChild(h.vm.$el);
      h.vm.$destroy();
    },
    fields: function fields() {
      return h.fields();
    },
    append: function append(rule, after, child) {
      // eslint-disable-next-line one-var
      var fields = Object.keys(h.fieldCtx),
          index = h.sort.length - 1,
          rules = void 0;

      if (rule.field && fields.indexOf(rule.field) > -1) {
        return Object(console["a" /* err */])(rule.field + ' \u5B57\u6BB5\u5DF2\u5B58\u5728', rule);
      }

      var ctx = h.getCtx(after);

      if (ctx) {
        if (child) {
          rules = ctx.rule.children;
          index = ctx.rule.children.length - 1;
        } else {
          index = ctx.root.indexOf(ctx.origin);
          rules = ctx.root;
        }
      } else rules = h.rules;
      rules.splice(index + 1, 0, rule);
    },
    prepend: function prepend(rule, after, child) {
      // eslint-disable-next-line one-var
      var fields = Object.keys(h.fieldCtx),
          index = 0,
          rules = void 0;

      if (rule.field && fields.indexOf(rule.field) > -1) {
        return Object(console["a" /* err */])(rule.field + ' \u5B57\u6BB5\u5DF2\u5B58\u5728', rule);
      }

      var ctx = h.getCtx(after);

      if (ctx) {
        if (child) {
          rules = ctx.rule.children;
        } else {
          index = ctx.root.indexOf(ctx.origin);
          rules = ctx.root;
        }
      } else rules = h.rules;
      rules.splice(index, 0, rule);
    },
    hidden: function hidden(state, fields) {
      props(fields, 'hidden', !!state);
      h.refresh();
    },
    hiddenStatus: function hiddenStatus(id) {
      var ctx = h.getCtx(id);
      if (!ctx) return;
      return !!ctx.rule.hidden;
    },
    display: function display(state, fields) {
      props(fields, 'display', !!state);
      h.refresh();
    },
    displayStatus: function displayStatus(id) {
      var ctx = h.getCtx(id);
      if (!ctx) return;
      return !!ctx.rule.display;
    },
    disabled: function disabled(_disabled, fields) {
      tidyFields(fields).forEach(function (field) {
        var ctx = h.fieldCtx[field];
        if (!ctx) return;
        Object(modify["b" /* $set */])(ctx.rule.props, 'disabled', !!_disabled);
      });
      h.refresh();
    },
    model: function model(origin) {
      return byRules(h.fieldCtx, origin);
    },
    component: function component(origin) {
      return byRules(h.nameCtx, origin);
    },
    bind: function bind() {
      return api.form;
    },

    reload: function reload(rules) {
      h.reloadRule(rules);
    },
    updateOptions: function updateOptions(options) {
      h.fc.updateOptions(options);
      api.refresh();
    },
    onSubmit: function onSubmit(fn) {
      api.updateOptions({ onSubmit: fn });
    },

    sync: function sync(field) {
      var ctx = utils_type["a" /* default */].Object(field) ? Object(util["a" /* byCtx */])(field) : h.getCtx(field);
      if (ctx && !ctx.deleted) {
        var subForm = h.subForm[field];
        if (subForm) {
          if (Array.isArray(subForm)) {
            subForm.forEach(function (form) {
              form.refresh();
            });
          } else if (subForm) {
            subForm.refresh();
          }
        }
        // ctx.updateKey(true);
        h.$render.clearCache(ctx);
        h.refresh();
      }
    },
    refresh: function refresh() {
      allSubForm().forEach(function (sub) {
        sub.refresh();
      });
      h.$render.clearCacheAll();
      h.refresh();
    },
    refreshOptions: function refreshOptions() {
      h.$manager.updateOptions(h.options);
      api.refresh();
    },

    hideForm: function hideForm(hide) {
      Object(modify["b" /* $set */])(h.vm, 'isShow', !hide);
    },
    changeStatus: function changeStatus() {
      return h.changeStatus;
    },
    clearChangeStatus: function clearChangeStatus() {
      h.changeStatus = false;
    },
    updateRule: function updateRule(id, rule) {
      var r = api.getRule(id);
      r && Object(extend["a" /* default */])(r, rule);
    },
    updateRules: function updateRules(rules) {
      Object.keys(rules).forEach(function (id) {
        api.updateRule(id, rules[id]);
      });
    },

    mergeRule: function mergeRule(id, rule) {
      var ctx = h.getCtx(id);
      ctx && Object(util["i" /* mergeRule */])(ctx.rule, rule);
    },
    mergeRules: function mergeRules(rules) {
      Object.keys(rules).forEach(function (id) {
        api.mergeRule(id, rules[id]);
      });
    },

    getRule: function getRule(id, origin) {
      var ctx = h.getCtx(id);
      if (ctx) {
        return origin ? ctx.origin : ctx.rule;
      }
    },
    updateValidate: function updateValidate(id, validate, merge) {
      if (merge) {
        api.mergeRule(id, { validate: validate });
      } else {
        props(id, 'validate', validate);
      }
    },
    updateValidates: function updateValidates(validates, merge) {
      Object.keys(validates).forEach(function (id) {
        api.updateValidate(id, validates[id], merge);
      });
    },
    refreshValidate: function refreshValidate() {
      h.vm.validate = {};
      api.refresh();
    },
    resetFields: function resetFields(fields) {
      var ctxs = h.fieldCtx;
      tidyFields(fields).forEach(function (field) {
        var ctx = ctxs[field];
        if (!ctx) return;
        h.$render.clearCache(ctx);
        ctx.rule.value = copy(ctx.defaultValue);
        h.refreshControl(ctx);
      });
    },
    method: function method(id, name) {
      var el = api.el(id);
      if (!el || !el[name]) throw new Error(Object(console["b" /* format */])('err', name + '\u65B9\u6CD5\u4E0D\u5B58\u5728'));
      return function () {
        return el[name].apply(el, arguments);
      };
    },
    exec: function exec(id, name) {
      for (var _len = arguments.length, args = Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {
        args[_key - 2] = arguments[_key];
      }

      return Object(util["g" /* invoke */])(function () {
        return api.method(id, name).apply(undefined, args);
      });
    },
    toJson: function toJson(space) {
      return Object(util["l" /* toJson */])(api.rule, space);
    },
    trigger: function trigger(id, event) {
      var el = api.el(id);

      for (var _len2 = arguments.length, args = Array(_len2 > 2 ? _len2 - 2 : 0), _key2 = 2; _key2 < _len2; _key2++) {
        args[_key2 - 2] = arguments[_key2];
      }

      el && el.$emit.apply(el, [event].concat(args));
    },
    el: function el(id) {
      var ctx = h.getCtx(id);
      if (ctx) return ctx.el || h.vm.$refs[ctx.ref];
    },

    closeModal: function closeModal(id) {
      var el = api.el(id);
      el && el.$emit && el.$emit('close-modal');
    },
    getSubForm: function getSubForm(field) {
      return h.subForm[field];
    },
    nextTick: function nextTick(fn) {
      h.bus.$once('next-tick', fn);
      h.refresh();
    },
    nextRefresh: function nextRefresh(fn) {
      h.nextRefresh();
      fn && Object(util["g" /* invoke */])(fn);
    }
  };

  ['on', 'once', 'off', 'set'].forEach(function (n) {
    api[n] = function () {
      var _h$vm;

      (_h$vm = h.vm)['$' + n].apply(_h$vm, arguments);
    };
  });

  api.changeValue = api.changeField = api.setValue;

  return api;
}
// CONCATENATED MODULE: ./packages/form-create/coreSrc/render/cache.js


function useCache(Render) {
  Object(extend["a" /* default */])(Render.prototype, {
    initCache: function initCache() {
      this.clearCacheAll();
    },
    clearCache: function clearCache(ctx) {
      if (!this.cache[ctx.id]) {
        ctx.parent && this.clearCache(ctx.parent);
        return;
      }
      if (this.cache[ctx.id].use === true || this.cache[ctx.id].parent) {
        this.$handle.refresh();
      }
      var parent = this.cache[ctx.id].parent;
      this.cache[ctx.id] = null;
      parent && this.clearCache(parent);
    },
    clearCacheAll: function clearCacheAll() {
      this.cache = {};
    },
    setCache: function setCache(ctx, vnode, parent) {
      this.cache[ctx.id] = {
        vnode: vnode,
        use: false,
        parent: parent
      };
    },
    getCache: function getCache(ctx) {
      var cache = this.cache[ctx.id];
      cache.use = true;
      return cache.vnode;
    }
  });
}
// EXTERNAL MODULE: ./packages/form-create/utils/mergeprops.js
var mergeprops = __webpack_require__(23);

// CONCATENATED MODULE: ./packages/form-create/utils/tocase.js
function toCase(str) {
  var to = str.replace(/(-[a-z])/g, function (v) {
    return v.replace('-', '').toLocaleUpperCase();
  });

  return tocase_lower(to);
}

function tocase_lower(str) {
  return str.replace(str[0], str[0].toLowerCase());
}
// CONCATENATED MODULE: ./packages/form-create/coreSrc/render/render.js
var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };

/* eslint-disable no-sequences */








function setTempProps(vm, ctx, api) {
  if (!vm.$props) return;

  var prop = ctx.prop;

  var keys = Object.keys(vm.$props);
  var inject = injectProp(ctx, api);
  var injectKeys = Object.keys(inject);

  keys.forEach(function (key) {
    if (Object(utils_type["b" /* hasProperty */])(prop.props, key)) {
      vm.$props[key] = prop.props[key];
    } else if (injectKeys.indexOf(key) > -1) vm.$props[key] = inject[key];
  });

  var key = vm.$options.model && vm.$options.model.prop || 'value';
  if (keys.indexOf(key) > -1) {
    vm.$props[key] = prop.value;
  }
}

function injectProp(ctx, api) {
  return {
    formCreate: api,
    formCreateField: ctx.field,
    formCreateOptions: ctx.prop.options,
    formCreateRule: function () {
      var temp = _extends({}, ctx.prop);
      // eslint-disable-next-line no-return-assign
      return temp.on = temp.on ? _extends({}, temp.on) : {}, temp;
    }()
  };
}

function useRender(Render) {
  Object(extend["a" /* default */])(Render.prototype, {
    initRender: function initRender() {
      this.renderList = {};
      this.clearOrgChildren();
    },
    initOrgChildren: function initOrgChildren() {
      var ctxs = this.$handle.ctxs;
      this.orgChildren = Object.keys(ctxs).reduce(function (initial, id) {
        var children = ctxs[id].rule.children;
        initial[id] = utils_type["a" /* default */].trueArray(children) ? [].concat(children) : [];

        return initial;
      }, {});
    },
    clearOrgChildren: function clearOrgChildren() {
      this.orgChildren = {};
    },
    render: function render() {
      var _this = this;

      if (!this.vm.isShow) {
        return;
      }
      this.$h = this.vm.$createElement;
      this.$manager.beforeRender();

      var vn = this.sort.map(function (id) {
        return _this.renderCtx(_this.$handle.ctxs[id]);
      }).filter(function (val) {
        return val !== undefined;
      });

      return this.$manager.render(vn);
    },
    makeVm: function makeVm(rule) {
      var _this2 = this;

      var vm = rule.vm;
      if (!vm) {
        return new _vue();
      } else if (utils_type["a" /* default */].Function(vm)) {
        return Object(util["g" /* invoke */])(function () {
          return vm(_this2.$handle.getInjectData(rule));
        });
      } else if (!vm._isVue) {
        return new _vue(vm);
      }
      return vm;
    },
    mergeGlobal: function mergeGlobal(ctx) {
      var g = this.$handle.options.global;
      if (!g) return;
      // todo 缓存配置,更新 option 更新
      if (!ctx.cacheConfig) {
        ctx.cacheConfig = g[ctx.originType] || g[ctx.type] || g[ctx.trueType] || {};
      }
      ctx.prop = Object(util["i" /* mergeRule */])({}, [g['*'], ctx.cacheConfig, ctx.prop]);
    },
    renderTemp: function renderTemp(ctx) {
      var _this3 = this;

      if (!_vue.compile) {
        Object(console["d" /* tip */])('当前使用的Vue构建版本不支持compile,无法使用template功能');
        return [];
      }
      var rule = ctx.prop;
      var id = ctx.id,
          key = ctx.key;


      if (!this.renderList[id]) {
        if (!ctx.el) {
          ctx.el = this.makeVm(rule);
          this.vm.$nextTick(function () {
            return ctx.parser.mounted(ctx);
          });
        }

        var _vm = ctx.el;
        if (ctx.input) {
          _vm.$on(_vm.$options.model && _vm.$options.model.event || 'input', function (value) {
            _this3.onInput(ctx, value);
          });
        }

        this.renderList[id] = {
          vm: _vm,
          template: _vue.compile(rule.template)
        };
      }

      var _renderList$id = this.renderList[id],
          vm = _renderList$id.vm,
          template = _renderList$id.template;


      setTempProps(vm, ctx, this.$handle.api);

      var vn = template.render.call(vm);

      if (utils_type["a" /* default */].Undef(vn.data)) vn.data = {};
      vn.key = key;
      vn.data.ref = ctx.ref;
      vn.data.key = key;
      return vn;
    },
    renderSides: function renderSides(vn, ctx, temp) {
      var prop = ctx[temp ? 'rule' : 'prop'];
      return [this.renderRule(prop.prefix), vn, this.renderRule(prop.suffix)];
    },
    renderCtx: function renderCtx(ctx, parent) {
      if (ctx.type === 'hidden') return;
      if (!this.cache[ctx.id]) {
        var vn = void 0;
        var cacheFlag = true;
        var _type = ctx.trueType;
        var none = !(utils_type["a" /* default */].Undef(ctx.rule.display) || !!ctx.rule.display);
        if (_type === 'template' && !ctx.rule.template) {
          vn = this.renderSides(this.renderChildren(ctx), ctx, true);
          if (none) {
            this.display(vn);
          }
          vn = this.item(ctx, vn);
        } else if (_type === 'fcFragment') {
          vn = this.renderChildren(ctx);
        } else {
          ctx.initProp();
          this.mergeGlobal(ctx);
          this.$manager.tidyRule(ctx);
          this.ctxProp(ctx);
          var prop = ctx.prop;

          if (prop.hidden) {
            this.setCache(ctx, undefined, parent);
            return;
          }

          if (_type === 'template' && prop.template) {
            vn = this.renderTemp(ctx);
            cacheFlag = false;
          } else {
            vn = ctx.parser.render(this.renderChildren(ctx), ctx);
          }
          vn = this.renderSides(vn, ctx);
          if (!(!ctx.input && utils_type["a" /* default */].Undef(prop.native)) && prop.native !== true) {
            vn = this.$manager.makeWrap(ctx, vn);
          }
          if (none) {
            vn = this.display(vn);
          }
          vn = this.item(ctx, vn);
        }
        if (cacheFlag) {
          this.setCache(ctx, vn, parent);
        }
        return vn;
      }

      return this.getCache(ctx);
    },
    display: function display(vn) {
      var _this4 = this;

      if (Array.isArray(vn)) {
        var data = [];
        vn.forEach(function (v) {
          if (Array.isArray(v)) return _this4.display(v);
          if (_this4.none(v)) data.push(v);
        });
        return data;
      } else {
        return this.none(vn);
      }
    },
    none: function none(vn) {
      if (vn && vn.data) {
        if (Array.isArray(vn.data.style)) {
          vn.data.style.push({ display: 'none' });
        } else {
          vn.data.style = [vn.data.style, { display: 'none' }];
        }
        return vn;
      }
    },
    item: function item(ctx, vn) {
      return this.$h('fcFragment', {
        slot: ctx.rule.slot,
        key: ctx.key
      }, [vn]);
    },
    ctxProp: function ctxProp(ctx, custom) {
      var _this5 = this;

      var ref = ctx.ref,
          key = ctx.key;

      this.$manager.mergeProp(ctx, custom);
      ctx.parser.mergeProp(ctx, custom);
      var props = [{
        props: injectProp(ctx, this.$handle.api),
        ref: ref,
        key: key + 'fc',
        slot: undefined
      }];

      if (!custom) {
        props.push({
          on: {
            'hook:mounted': function hookMounted() {
              _this5.onMounted(ctx);
            },
            'fc.sub-form': function fcSubForm(subForm) {
              _this5.$handle.addSubForm(ctx, subForm);
            }
          },
          model: ctx.input ? {
            value: this.$handle.getFormData(ctx),
            callback: function callback(value) {
              _this5.onInput(ctx, value);
            },
            expression: 'formData.' + ctx.field
          } : undefined
        });
      }
      Object(mergeprops["a" /* default */])(props, ctx.prop);
      return ctx.prop;
    },
    onMounted: function onMounted(ctx) {
      ctx.el = this.vm.$refs[ctx.ref];
      ctx.parser.mounted(ctx);
      this.$handle.effect(ctx, 'mounted');
    },
    onInput: function onInput(ctx, value) {
      this.$handle.onInput(ctx, value);
    },
    renderChildren: function renderChildren(ctx) {
      var _this6 = this;

      // eslint-disable-next-line one-var
      var children = ctx.rule.children,
          orgChildren = this.orgChildren[ctx.id];

      if (!utils_type["a" /* default */].trueArray(children) && orgChildren) {
        this.$handle.deferSyncValue(function () {
          orgChildren.forEach(function (child) {
            if (!utils_type["a" /* default */].String(child) && child.__fc__) {
              _this6.$handle.rmCtx(child.__fc__);
            }
          });
        });
        this.orgChildren[ctx.id] = [];
        return [];
      }

      orgChildren && this.$handle.deferSyncValue(function () {
        orgChildren.forEach(function (child) {
          if (children.indexOf(child) === -1 && !utils_type["a" /* default */].String(child) && child.__fc__) {
            _this6.$handle.rmCtx(child.__fc__);
          }
        });
      });

      return children.map(function (child) {
        if (utils_type["a" /* default */].String(child)) return child;
        if (child.__fc__) {
          return _this6.renderCtx(child.__fc__, ctx);
        }
        if (!_this6.$handle.isRepeatRule(child.__origin__ || child) && child.type) {
          _this6.vm.$nextTick(function () {
            _this6.$handle.loadChildren(children, ctx);
            _this6.$handle.refresh();
          });
        }
      });
    },
    defaultRender: function defaultRender(ctx, children) {
      var prop = ctx.prop;
      if (this.vNode[ctx.type]) {
        return this.vNode[ctx.type](prop, children);
      }
      if (this.vNode[ctx.originType]) {
        return this.vNode[ctx.originType](prop, children);
      }
      return this.vNode.make(tocase_lower(ctx.originType), prop, children);
    },
    renderRule: function renderRule(rule, children, origin) {
      var _this7 = this;

      if (!rule) return undefined;
      if (utils_type["a" /* default */].String(rule)) return rule;

      var type = void 0;
      if (origin) {
        type = rule.type;
      } else {
        type = rule.is;
        if (rule.type) {
          type = toCase(rule.type);
          var alias = this.vNode.aliasMap[type];
          if (alias) type = toCase(alias);
        }
      }

      if (!type) return undefined;
      var data = [[children]];
      if (utils_type["a" /* default */].trueArray(rule.children)) {
        data.push(rule.children.map(function (v) {
          return _this7.renderRule(v);
        }));
      }
      return this.$h(type, _extends({}, rule), data);
    }
  });
}
// CONCATENATED MODULE: ./packages/form-create/coreSrc/render/index.js





function render_Render(handle) {
  Object(extend["a" /* default */])(this, {
    $handle: handle,
    fc: handle.fc,
    vm: handle.vm,
    $manager: handle.$manager,
    vNode: new handle.fc.CreateNode(handle.vm)
  });

  Object(util["e" /* funcProxy */])(this, {
    options: function options() {
      return handle.options;
    },
    sort: function sort() {
      return handle.sort;
    }
  });

  this.initCache();
  this.initRender();
}

useCache(render_Render);
useRender(render_Render);
// CONCATENATED MODULE: ./packages/form-create/coreSrc/handler/inject.js




function useInject(Handler) {
  Object(extend["a" /* default */])(Handler.prototype, {
    parseInjectEvent: function parseInjectEvent(rule, on) {
      var _this = this;

      if (rule.inject === false) return;
      var inject = rule.inject || this.options.injectEvent;
      if (utils_type["a" /* default */].Undef(inject)) return;
      Object.keys(on).forEach(function (k) {
        if (utils_type["a" /* default */].Function(on[k])) {
          on[k] = _this.inject(rule, on[k], inject);
        };
      });
      return on;
    },
    parseEmit: function parseEmit(ctx, on) {
      var _this2 = this;

      // eslint-disable-next-line one-var
      var event = {},
          rule = ctx.rule,
          emitPrefix = rule.emitPrefix,
          field = rule.field,
          name = rule.name,
          inject = rule.inject;
      var emit = rule[on ? 'emit' : 'nativeEmit'] || [];
      if (utils_type["a" /* default */].trueArray(emit)) {
        var emitKey = emitPrefix || field || name;
        if (emitKey) {
          if (!on) emitKey = 'native-' + emitKey;
          emit.forEach(function (eventName) {
            if (!eventName) return;
            var eventInject = void 0;
            if (utils_type["a" /* default */].Object(eventName)) {
              eventInject = eventName.inject;
              eventName = eventName.name;
            }
            var fieldKey = toLine(emitKey + '-' + eventName);
            var fn = function fn() {
              var _vm, _vm2;

              for (var _len = arguments.length, arg = Array(_len), _key = 0; _key < _len; _key++) {
                arg[_key] = arguments[_key];
              }

              (_vm = _this2.vm).$emit.apply(_vm, [fieldKey].concat(arg));
              (_vm2 = _this2.vm).$emit.apply(_vm2, ['emit-event', fieldKey].concat(arg));
            };
            fn.__emit = true;

            if (!eventInject && inject === false) {
              event[eventName] = fn;
            } else {
              var _inject = eventInject || inject || _this2.options.injectEvent;
              event[eventName] = utils_type["a" /* default */].Undef(_inject) ? fn : _this2.inject(rule, fn, _inject);
            }
          });
        }
      }
      ctx.computed[on ? 'on' : 'nativeOn'] = event;
      return event;
    },
    getInjectData: function getInjectData(self, inject) {
      var _vm$$options$propsDat = this.vm.$options.propsData,
          option = _vm$$options$propsDat.option,
          rule = _vm$$options$propsDat.rule;

      return {
        $f: this.api,
        rule: rule,
        self: self.__origin__,
        option: option,
        inject: inject
      };
    },
    inject: function inject(self, _fn, _inject2) {
      if (_fn.__inject) {
        if (this.watching && !this.loading) {
          return _fn;
        }
        _fn = _fn.__origin;
      }

      var h = this;

      var fn = function fn() {
        for (var _len2 = arguments.length, args = Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
          args[_key2] = arguments[_key2];
        }

        args.unshift(h.getInjectData(self, _inject2));
        return _fn.apply(this, args);
      };
      fn.__inject = true;
      fn.__origin = _fn;
      return fn;
    }
  });
}
// CONCATENATED MODULE: ./packages/form-create/coreSrc/handler/page.js



var EVENT = ['hook:updated', 'hook:mounted'];

function page_usePage(Handler) {
  Object(extend["a" /* default */])(Handler.prototype, {
    usePage: function usePage() {
      var _this = this;

      var page = this.options.page;
      if (!page) return;
      var first = 25;
      var limit = getLimit(this.rules);
      if (utils_type["a" /* default */].Object(page)) {
        if (page.first) first = parseInt(page.first, 10) || first;
        if (page.limit) limit = parseInt(page.limit, 10) || limit;
      }
      Object(extend["a" /* default */])(this, {
        first: first,
        limit: limit,
        pageEnd: this.rules.length <= first
      });

      this.bus.$on('page-end', function () {
        return _this.vm.$emit('page-end', _this.api);
      });
      this.pageLoad();
    },
    pageLoad: function pageLoad() {
      var _this2 = this;

      var pageFn = function pageFn() {
        if (_this2.pageEnd) {
          _this2.vm.$off(EVENT, pageFn);
          _this2.bus.$emit('page-end');
        } else {
          _this2.first += _this2.limit;
          _this2.pageEnd = _this2.rules.length <= _this2.first;
          _this2.loadRule();
          _this2.refresh();
        }
      };
      this.vm.$on(EVENT, pageFn);
    }
  });
}

function getLimit(rules) {
  return rules.length < 31 ? 31 : Math.ceil(rules.length / 3);
}
// CONCATENATED MODULE: ./packages/form-create/coreSrc/handler/render.js


function render_useRender(Handler) {
  Object(extend["a" /* default */])(Handler.prototype, {
    clearNextTick: function clearNextTick() {
      this.nextTick && clearTimeout(this.nextTick);
      this.nextTick = null;
    },
    bindNextTick: function bindNextTick(fn) {
      var _this = this;

      this.clearNextTick();
      this.nextTick = setTimeout(function () {
        fn();
        _this.nextTick = null;
      }, 10);
    },
    render: function render() {
      // console.warn('%c render', 'color:green');
      ++this.loadedId;

      if (this.vm.unique > 0) {
        return this.$render.render();
      } else {
        this.vm.unique = 1;
        return [];
      }
    }
  });
}
// CONCATENATED MODULE: ./packages/form-create/coreSrc/factory/context.js
var context_extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };








function bind(ctx) {
  Object.defineProperties(ctx.origin, {
    __fc__: Object(util["d" /* enumerable */])(ctx, true)
  });
}

function RuleContext(handle, rule) {
  var id = uniqueId();

  Object(extend["a" /* default */])(this, {
    id: id,
    ref: id,
    wrapRef: id + 'fi',
    rule: rule,
    origin: rule.__origin__ || rule,
    name: rule.name,

    watch: [],
    linkOn: [],
    root: [],
    ctrlRule: [],
    parent: null,
    cacheConfig: null,
    prop: context_extends({}, rule),
    computed: {},
    payload: {},
    input: !!rule.field,
    el: undefined,
    defaultValue: rule.field ? Object(deepextend["a" /* deepCopy */])(rule.value) : undefined,
    field: rule.field || undefined
  });

  this.updateType();
  this.updateKey();
  bind(this);
  this.update(handle, true);
}

Object(extend["a" /* default */])(RuleContext.prototype, {
  effectData: function effectData(name) {
    if (!this.payload[name]) {
      this.payload[name] = {};
    }
    return this.payload[name];
  },
  clearEffectData: function clearEffectData(name) {
    delete this.payload[name];
  },
  updateKey: function updateKey(flag) {
    this.key = uniqueId();
    flag && this.parent && this.parent.updateKey(flag);
  },
  updateType: function updateType() {
    this.originType = this.rule.type;
    this.type = toCase(this.rule.type);
  },
  setParser: function setParser(parser) {
    this.parser = parser;
    parser.init(this);
  },
  initProp: function initProp() {
    var _this = this;

    this.prop = Object(mergeprops["a" /* default */])([this.rule].concat(Object.keys(this.payload).map(function (k) {
      return _this.payload[k];
    }), [this.computed]));
  },
  check: function check(handle) {
    return this.vm === handle.vm;
  },
  unwatch: function unwatch() {
    this.watch.forEach(function (un) {
      return un();
    });
    this.watch = [];
  },
  unlink: function unlink() {
    this.linkOn.forEach(function (un) {
      return un();
    });
    this.linkOn = [];
  },
  link: function link() {
    this.unlink();
    this.$handle.appendLink(this);
  },
  watchTo: function watchTo() {
    this.$handle.watchCtx(this);
  },
  delete: function _delete() {
    var undef = void 0;
    this.unwatch();
    this.unlink();
    this.rmCtrl();
    Object(extend["a" /* default */])(this, {
      deleted: true,
      prop: context_extends({}, this.rule),
      computed: {},
      el: undef,
      $handle: undef,
      $render: undef,
      $api: undef,
      vm: undef,
      vNode: undef,
      parent: null,
      cacheConfig: null
    });
  },
  rmCtrl: function rmCtrl() {
    this.ctrlRule.forEach(function (ctrl) {
      return ctrl.__fc__.rm();
    });
    this.ctrlRule = [];
  },
  rm: function rm() {
    var _this2 = this;

    var _rm = function _rm() {
      var index = _this2.root.indexOf(_this2.origin);
      if (index > -1) {
        _this2.root.splice(index, 1);
        _this2.$handle.refresh();
      }
    };
    if (this.deleted) {
      _rm();
      return;
    }
    this.$handle.noWatch(function () {
      _this2.$handle.deferSyncValue(function () {
        _this2.rmCtrl();
        _rm();
        _this2.$handle.rmCtx(_this2);
        Object(extend["a" /* default */])(_this2, {
          root: []
        });
      });
    });
  },
  update: function update(handle, init) {
    Object(extend["a" /* default */])(this, {
      deleted: false,
      $handle: handle,
      $render: handle.$render,
      $api: handle.api,
      vm: handle.vm,
      trueType: handle.getType(this.originType),
      vNode: handle.$render.vNode,
      updated: false
    });
    !init && this.unwatch();
    this.watchTo();
    this.link();
  }
});
// CONCATENATED MODULE: ./packages/form-create/coreSrc/handler/loader.js
var loader_extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };









function useLoader(Handler) {
  Object(extend["a" /* default */])(Handler.prototype, {
    nextRefresh: function nextRefresh(fn) {
      var _this = this;

      var id = this.loadedId;
      this.vm.$nextTick(function () {
        id === _this.loadedId && (fn ? fn() : _this.refresh());
      });
    },
    parseRule: function parseRule(_rule) {
      var _this2 = this;

      var rule = Object(util["f" /* getRule */])(_rule);

      Object.defineProperties(rule, {
        __origin__: Object(util["d" /* enumerable */])(_rule, true)
      });

      fullRule(rule);

      if (rule.field && Object(utils_type["b" /* hasProperty */])(this.options.formData || {}, rule.field)) {
        rule.value = this.options.formData[rule.field];
      }

      rule.options = Array.isArray(rule.options) ? rule.options : [];

      ['on', 'props', 'nativeOn'].forEach(function (k) {
        var v = rule[k];
        if (v) {
          Object.keys(v).forEach(function (n) {
            v[n] = Object(util["j" /* parseFn */])(v[n]);
          });
          _this2.parseInjectEvent(rule, v);
        }
      });

      return rule;
    },
    syncProp: function syncProp(ctx) {
      var _this3 = this;

      var rule = ctx.rule;
      utils_type["a" /* default */].trueArray(rule.sync) && Object(mergeprops["a" /* default */])([{
        on: rule.sync.reduce(function (pre, prop) {
          pre['update:' + prop] = function (val) {
            rule.props[prop] = val;
            _this3.vm.$emit('sync', prop, val, rule, _this3.fapi);
          };
          return pre;
        }, {})
      }], ctx.computed);
    },
    isRepeatRule: function isRepeatRule(rule) {
      return this.repeatRule.indexOf(rule) > -1;
    },
    loadRule: function loadRule() {
      var _this4 = this;

      // console.warn('%c load', 'color:blue');
      this.cycleLoad = false;
      this.loading = true;
      if (this.pageEnd) {
        this.bus.$emit('load-start');
      }
      this.deferSyncValue(function () {
        _this4._loadRule(_this4.rules);
        _this4.loading = false;
        if (_this4.cycleLoad && _this4.pageEnd) {
          return _this4.loadRule();
        }
        if (_this4.pageEnd) {
          _this4.bus.$emit('load-end');
        }
        _this4.vm._renderRule();
        _this4.$render.initOrgChildren();
        _this4.syncForm();
      });
    },
    loadChildren: function loadChildren(children, parent) {
      this.cycleLoad = false;
      this.loading = true;
      this.bus.$emit('load-start');
      this._loadRule(children, parent);
      this.loading = false;
      if (this.cycleLoad) {
        return this.loadRule();
      } else {
        this.bus.$emit('load-end');
        this.syncForm();
      }
      this.$render.clearCache(parent);
    },
    _loadRule: function _loadRule(rules, parent) {
      var _this5 = this;

      var preIndex = function preIndex(i) {
        var pre = rules[i - 1];
        if (!pre || !pre.__fc__) {
          return i > 0 ? preIndex(i - 1) : -1;
        }
        var index = _this5.sort.indexOf(pre.__fc__.id);
        return index > -1 ? index : preIndex(i - 1);
      };

      var loadChildren = function loadChildren(children, parent) {
        if (utils_type["a" /* default */].trueArray(children)) {
          _this5._loadRule(children, parent);
        }
      };

      var initEvent = function initEvent(rule) {
        return _this5.ruleEffect(rule, 'init');
      };

      rules.map(function (_rule, index) {
        if (parent && utils_type["a" /* default */].String(_rule)) return;
        if (!_this5.pageEnd && !parent && index >= _this5.first) return;

        if (!utils_type["a" /* default */].Object(_rule) || !Object(util["f" /* getRule */])(_rule).type) {
          return Object(console["a" /* err */])('未定义生成规则的 type 字段', _rule);
        }

        if (_rule.__fc__ && _rule.__fc__.root === rules && _this5.ctxs[_rule.__fc__.id]) {
          loadChildren(_rule.__fc__.rule.children, _rule.__fc__);
          return _rule.__fc__;
        }

        var rule = Object(util["f" /* getRule */])(_rule);

        if (!_rule.__fc__) initEvent(rule);

        if (rule.field && _this5.fieldCtx[rule.field] && _this5.fieldCtx[rule.field] !== _rule.__fc__) {
          _this5.repeatRule.push(_rule);
          return Object(console["a" /* err */])(rule.field + ' \u5B57\u6BB5\u5DF2\u5B58\u5728', _rule);
        }

        var ctx = void 0;
        if (_rule.__fc__) {
          ctx = _rule.__fc__;
          var check = !ctx.check(_this5);
          if (ctx.deleted) {
            if (check) {
              if (isCtrl(ctx)) {
                return;
              }
              ctx.update(_this5);
            }
          } else {
            if (check) {
              if (isCtrl(ctx)) {
                return;
              }
              rules[index] = _rule = _rule._clone ? _rule._clone() : Object(util["b" /* copyRule */])(_rule);
              initEvent(Object(util["f" /* getRule */])(_rule));
              ctx = null;
            }
          }
        }
        if (!ctx) {
          ctx = new RuleContext(_this5, _this5.parseRule(_rule));
          _this5.bindParser(ctx);
        } else if (ctx.originType !== ctx.rule.type) {
          ctx.updateType();
          _this5.bindParser(ctx);
        }
        _this5.appendValue(ctx.rule);
        [false, true].forEach(function (b) {
          return _this5.parseEmit(ctx, b);
        });
        _this5.syncProp(ctx);
        ctx.parent = parent || null;
        ctx.root = rules;
        _this5.setCtx(ctx);

        loadChildren(ctx.rule.children, ctx);

        if (!parent) {
          var _preIndex = preIndex(index);
          if (_preIndex > -1) {
            _this5.sort.splice(_preIndex + 1, 0, ctx.id);
          } else {
            _this5.sort.push(ctx.id);
          }
        }

        var r = ctx.rule;
        if (!ctx.updated) {
          ctx.updated = true;
          if (utils_type["a" /* default */].Function(r.update)) {
            _this5.bus.$once('load-end', function () {
              _this5.refreshUpdate(ctx, r.value);
            });
          }
          _this5.effect(ctx, 'loaded');
        }

        if (ctx.input) {
          Object.defineProperty(r, 'value', _this5.valueHandle(ctx));
        }
        if (_this5.refreshControl(ctx)) _this5.cycleLoad = true;
        return ctx;
      });
    },
    refreshControl: function refreshControl(ctx) {
      return ctx.input && ctx.rule.control && this.useCtrl(ctx);
    },
    useCtrl: function useCtrl(ctx) {
      var _this6 = this;

      // eslint-disable-next-line one-var
      var controls = getCtrl(ctx),
          validate = [],
          api = this.api;
      if (!controls.length) return false;

      var _loop = function _loop(i) {
        // eslint-disable-next-line one-var
        var control = controls[i],
            handleFn = control.handle || function (val) {
          return val === control.value;
        };
        var data = loader_extends({}, control, {
          valid: Object(util["g" /* invoke */])(function () {
            return handleFn(ctx.rule.value, api);
          }),
          ctrl: findCtrl(ctx, control.rule)
        });
        if (data.valid && data.ctrl || !data.valid && !data.ctrl) return 'continue';
        validate.push(data);
      };

      for (var i = 0; i < controls.length; i++) {
        var _ret = _loop(i);

        if (_ret === 'continue') continue;
      }
      if (!validate.length) return false;

      var flag = false;
      validate.reverse().forEach(function (_ref) {
        var valid = _ref.valid,
            rule = _ref.rule,
            prepend = _ref.prepend,
            append = _ref.append,
            child = _ref.child,
            ctrl = _ref.ctrl;

        if (valid) {
          flag = true;
          var ruleCon = {
            type: 'fcFragment',
            native: true,
            __ctrl: true,
            children: rule
          };
          ctx.ctrlRule.push(ruleCon);
          _this6.bus.$once('load-start', function () {
            // this.cycleLoad = true;
            if (prepend) {
              api.prepend(ruleCon, prepend, child);
            } else if (append || child) {
              api.append(ruleCon, append || ctx.id, child);
            } else {
              ctx.root.splice(ctx.root.indexOf(ctx.origin) + 1, 0, ruleCon);
            }
          });
        } else {
          ctx.ctrlRule.splice(ctx.ctrlRule.indexOf(ctrl), 1);
          var ctrlCtx = Object(util["a" /* byCtx */])(ctrl);
          ctrlCtx && ctrlCtx.rm();
        }
      });
      this.vm.$emit('control', ctx.origin, this.api);
      this.effect(ctx, 'control');
      return flag;
    },
    reloadRule: function reloadRule(rules) {
      return this._reloadRule(rules);
    },
    _reloadRule: function _reloadRule(rules) {
      var _this7 = this;

      // console.warn('%c reload', 'color:red');
      if (!rules) rules = this.rules;

      var ctxs = loader_extends({}, this.ctxs);

      this.clearNextTick();
      this.$render.clearOrgChildren();
      this.initData(rules);
      this.fc.rules = rules;

      this.bus.$once('load-end', function () {
        Object.keys(ctxs).filter(function (id) {
          return _this7.ctxs[id] === undefined;
        }).forEach(function (id) {
          return _this7.rmCtx(ctxs[id]);
        });
        _this7.$render.clearCacheAll();
      });
      this.reloading = true;
      this.loadRule();
      this.reloading = false;
      this.refresh();

      this.bus.$off('next-tick', this.nextReload);
      this.bus.$once('next-tick', this.nextReload);
    },

    // todo 组件生成全部通过 alias
    refresh: function refresh() {
      this.vm._refresh();
    }
  });
}

function fullRule(rule) {
  var def = baseRule();

  Object.keys(def).forEach(function (k) {
    if (!Object(utils_type["b" /* hasProperty */])(rule, k)) rule[k] = def[k];
  });
  return rule;
}

function getCtrl(ctx) {
  var control = ctx.rule.control || [];
  if (utils_type["a" /* default */].Object(control)) return [control];else return control;
}

function findCtrl(ctx, rule) {
  for (var i = 0; i < ctx.ctrlRule.length; i++) {
    var ctrl = ctx.ctrlRule[i];
    if (ctrl.children === rule) {
      return ctrl;
    }
  }
}

function isCtrl(ctx) {
  return !!ctx.rule.__ctrl;
}
// CONCATENATED MODULE: ./packages/form-create/coreSrc/handler/input.js
var input_extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };







function useInput(Handler) {
  Object(extend["a" /* default */])(Handler.prototype, {
    getValue: function getValue(ctx) {
      if (!Object(utils_type["b" /* hasProperty */])(ctx, 'cacheValue')) {
        ctx.cacheValue = ctx.parser.toValue(this.getFormData(ctx), ctx);
      }
      return ctx.cacheValue;
    },
    setValue: function setValue(ctx, value, formValue, setFlag) {
      if (ctx.deleted) return;
      ctx.cacheValue = value;
      this.changeStatus = true;
      this.nextRefresh();
      this.$render.clearCache(ctx);
      this.setFormData(ctx, formValue);
      this.syncValue();
      this.valueChange(ctx, value);
      this.vm.$emit('change', ctx.field, value, ctx.origin, this.api, setFlag);
      this.effect(ctx, 'value');
    },
    onInput: function onInput(ctx, value) {
      var val = void 0;
      if (ctx.input && (this.isQuote(ctx, val = ctx.parser.toValue(value, ctx)) || this.isChange(ctx, val))) {
        this.setValue(ctx, val, value);
      }
    },
    setFormData: function setFormData(ctx, value) {
      Object(modify["b" /* $set */])(this.formData, ctx.field, value);
    },
    getFormData: function getFormData(ctx) {
      return this.formData[ctx.field];
    },
    validate: function validate() {
      var _this = this;

      toEmpty(this.vm.validate);
      Object.keys(this.fieldCtx).forEach(function (id) {
        var ctx = _this.fieldCtx[id];
        _this.vm.validate[ctx.field] = Object(toarray["a" /* default */])(ctx.rule.validate);
      });
      return this.vm.validate;
    },
    syncForm: function syncForm() {
      var _this2 = this;

      toEmpty(this.form);
      Object.defineProperties(this.form, Object.keys(this.formData).reduce(function (initial, field) {
        var ctx = _this2.getCtx(field);
        var handle = _this2.valueHandle(ctx);
        handle.configurable = true;
        initial[field] = handle;
        return initial;
      }, {}));
      this.syncValue();
    },
    valueHandle: function valueHandle(ctx) {
      var _this3 = this;

      return {
        enumerable: true,
        get: function get() {
          return _this3.getValue(ctx);
        },
        set: function set(value) {
          if (_this3.isChange(ctx, value)) {
            _this3.setValue(ctx, value, ctx.parser.toFormValue(value, ctx), true);
          }
        }
      };
    },
    appendValue: function appendValue(rule) {
      if (!rule.field || !Object(utils_type["b" /* hasProperty */])(this.appendData, rule.field)) return;
      rule.value = this.appendData[rule.field];
      delete this.appendData[rule.field];
    },
    addSubForm: function addSubForm(ctx, subForm) {
      this.subForm[ctx.field] = subForm;
    },
    deferSyncValue: function deferSyncValue(fn) {
      if (!this.deferSyncFn) {
        this.deferSyncFn = fn;
      }
      Object(util["g" /* invoke */])(fn);
      if (this.deferSyncFn === fn) {
        this.deferSyncFn = null;
        if (fn.sync) {
          this.syncValue();
        }
      }
    },
    syncValue: function syncValue() {
      if (this.deferSyncFn) {
        // eslint-disable-next-line no-return-assign
        return this.deferSyncFn.sync = true;
      }
      this.vm._updateValue(input_extends({}, this.form));
    },
    isChange: function isChange(ctx, value) {
      return JSON.stringify(ctx.rule.value) !== JSON.stringify(value);
    },
    isQuote: function isQuote(ctx, value) {
      return (utils_type["a" /* default */].Object(value) || Array.isArray(value)) && value === ctx.rule.value;
    },
    refreshUpdate: function refreshUpdate(ctx, val) {
      var _this4 = this;

      var fn = ctx.rule.update;
      if (utils_type["a" /* default */].Function(fn)) {
        var state = Object(util["g" /* invoke */])(function () {
          return fn(val, ctx.origin, _this4.api);
        });
        if (state === undefined) return;
        ctx.rule.hidden = state === true;
      }
    },
    valueChange: function valueChange(ctx, val) {
      this.refreshRule(ctx, val);
      this.bus.$emit('change-' + ctx.field, val);
    },
    refreshRule: function refreshRule(ctx, val) {
      if (this.refreshControl(ctx)) {
        this.$render.clearCacheAll();
        this.loadRule();
        this.refresh();
      }
      this.refreshUpdate(ctx, val);
    },
    appendLink: function appendLink(ctx) {
      var _this5 = this;

      var link = ctx.rule.link;
      utils_type["a" /* default */].trueArray(link) && link.forEach(function (field) {
        var fn = function fn() {
          return _this5.refreshRule(ctx, ctx.rule.value);
        };

        _this5.bus.$on('change-' + field, fn);
        ctx.linkOn.push(function () {
          return _this5.bus.$off('change-' + field, fn);
        });
      });
    },
    fields: function fields() {
      return Object.keys(this.formData);
    }
  });
}

function toEmpty(obj) {
  Object.keys(obj).forEach(function (k) {
    return delete obj[k];
  });
}
// CONCATENATED MODULE: ./packages/form-create/coreSrc/handler/helper.js



function useHelper(rules) {
  if (!Array.isArray(rules) || rules.findField) return;
  Object.defineProperties(rules, {
    findField: Object(util["d" /* enumerable */])(findField),
    findName: Object(util["d" /* enumerable */])(findName),
    setValue: Object(util["d" /* enumerable */])(setValue)
  });
}

function find(field, name, origin) {
  if (!this.length) return;
  var children = [];
  for (var i = 0; i < this.length; i++) {
    if (!utils_type["a" /* default */].Object(this[i])) continue;
    var rule = Object(util["f" /* getRule */])(this[i]);
    if (rule[name] === field) return origin ? rule : this[i];
    if (utils_type["a" /* default */].trueArray(rule.children)) children = children.concat(rule.children);
    utils_type["a" /* default */].trueArray(rule.control) && rule.control.forEach(function (r) {
      children = children.concat(r.rule);
    });
  }
  return find.call(children, field, name, origin);
}

function findField(field) {
  return find.call(this, field, 'field');
}

function findName(field) {
  return find.call(this, field, 'name');
}

function setValue(formData) {
  var _this = this;

  Object.keys(formData).forEach(function (field) {
    var rule = find.call(_this, field, 'field', true);
    if (rule) rule.value = formData[field];
  });
}
// CONCATENATED MODULE: ./packages/form-create/coreSrc/factory/parser.js
/* eslint-disable no-unused-vars */
var BaseParser = {
  init: function init(ctx) {},
  toFormValue: function toFormValue(value, ctx) {
    return value;
  },
  toValue: function toValue(formValue, ctx) {
    return formValue;
  },
  mounted: function mounted(ctx) {},
  render: function render(children, ctx) {
    return ctx.$render.defaultRender(ctx, children);
  },
  mergeProp: function mergeProp(ctx) {}
};

/* harmony default export */ var factory_parser = (BaseParser);
// CONCATENATED MODULE: ./packages/form-create/coreSrc/handler/context.js







function useContext(Handler) {
  Object(extend["a" /* default */])(Handler.prototype, {
    getCtx: function getCtx(id) {
      return this.fieldCtx[id] || this.nameCtx[id] || this.ctxs[id];
    },
    setCtx: function setCtx(ctx) {
      var id = ctx.id,
          field = ctx.field,
          name = ctx.name,
          rule = ctx.rule;

      this.ctxs[id] = ctx;
      if (name) Object(modify["b" /* $set */])(this.nameCtx, name, ctx);
      if (!ctx.input) return;
      this.fieldCtx[field] = ctx;
      this.setFormData(ctx, ctx.parser.toFormValue(rule.value, ctx));
    },
    getParser: function getParser(ctx) {
      var list = this.fc.parsers;
      return list[ctx.originType] || list[toCase(ctx.type)] || list[ctx.trueType] || factory_parser;
    },
    bindParser: function bindParser(ctx) {
      ctx.setParser(this.getParser(ctx));
    },
    getType: function getType(alias) {
      var map = this.fc.CreateNode.aliasMap;
      var type = map[alias] || map[toCase(alias)] || alias;
      return toCase(type);
    },
    noWatch: function noWatch(fn) {
      if (!this.noWatchFn) {
        this.noWatchFn = fn;
      }
      Object(util["g" /* invoke */])(fn);
      if (this.noWatchFn === fn) {
        this.noWatchFn = null;
      }
    },
    watchCtx: function watchCtx(ctx) {
      var _this = this;

      var vm = this.vm;
      var none = ['field', 'value', 'vm', 'template', 'name', 'config', 'control', 'inject', 'sync', 'payload'];
      Object.keys(ctx.rule).filter(function (k) {
        return none.indexOf(k) === -1;
      }).forEach(function (key) {
        var flag = key === 'children';
        ctx.watch.push(vm.$watch(function () {
          return ctx.rule[key];
        }, function (n, o) {
          if (_this.loading || _this.noWatchFn || _this.reloading) return;
          _this.watching = true;
          // if (key === 'hidden')
          //     ctx.updateKey(true);
          // else
          if (key === 'link') {
            ctx.link();
            return;
          } else if (['props', 'on', 'nativeOn'].indexOf(key) > -1) {
            _this.parseInjectEvent(ctx.rule, n || {});
            if (key === 'props' && ctx.input) {
              _this.setFormData(ctx, ctx.parser.toFormValue(ctx.rule.value, ctx));
            }
          } else if (['emit', 'nativeEmit'].indexOf(key) > -1) {
            _this.parseEmit(ctx, key === 'emit');
          } else if (key === 'type') {
            ctx.updateType();
            _this.bindParser(ctx);
          } else if (key === 'children') {
            var _flag = utils_type["a" /* default */].trueArray(n);
            _this.deferSyncValue(function () {
              if (n !== o) {
                _this.rmSub(o);
                _this.$render.initOrgChildren();
              }
              _flag && _this.loadChildren(n, ctx);
            });
          }
          _this.$render.clearCache(ctx);
          _this.watching = false;
        }, { deep: !flag, sync: flag }));
      });
      this.watchEffect(ctx);
    },
    rmSub: function rmSub(sub) {
      var _this2 = this;

      utils_type["a" /* default */].trueArray(sub) && sub.forEach(function (r) {
        r && r.__fc__ && _this2.rmCtx(r.__fc__);
      });
    },
    rmCtx: function rmCtx(ctx) {
      var _this3 = this;

      if (ctx.deleted) return;
      var id = ctx.id,
          field = ctx.field,
          name = ctx.name;

      if (ctx.input) {
        Object.defineProperty(ctx.rule, 'value', {
          value: ctx.rule.value,
          writable: true
        });
      }

      Object(modify["a" /* $del */])(this.ctxs, id);
      Object(modify["a" /* $del */])(this.$render.renderList, id);
      Object(modify["a" /* $del */])(this.$render.orgChildren, id);
      Object(modify["a" /* $del */])(ctx, 'cacheValue');

      var f = this.fieldCtx[field];

      if (field && (!f || f === ctx)) {
        Object(modify["a" /* $del */])(this.formData, field);
        Object(modify["a" /* $del */])(this.form, field);
        Object(modify["a" /* $del */])(this.fieldCtx, field);
        Object(modify["a" /* $del */])(this.subForm, field);
      }
      if (name && this.nameCtx[name] === ctx) {
        Object(modify["a" /* $del */])(this.nameCtx, name);
      }
      if (!this.reloading) {
        this.deferSyncValue(function () {
          if (utils_type["a" /* default */].trueArray(ctx.rule.children)) {
            ctx.rule.children.forEach(function (h) {
              return h.__fc__ && _this3.rmCtx(h.__fc__);
            });
          }
          _this3.syncValue();
        });
        if (ctx.root === this.rules) {
          this.vm._renderRule();
        }
      }

      var index = this.sort.indexOf(id);
      if (index > -1) {
        this.sort.splice(index, 1);
      }

      this.$render.clearCache(ctx);
      ctx.delete();
      this.effect(ctx, 'deleted');
      return ctx;
    }
  });
}
// CONCATENATED MODULE: ./packages/form-create/coreSrc/handler/lifecycle.js




function useLifecycle(Handler) {
  Object(extend["a" /* default */])(Handler.prototype, {
    mounted: function mounted() {
      var _this = this;

      var _mounted = function _mounted() {
        _this.isMounted = true;
        _this.lifecycle('mounted');
      };
      if (this.pageEnd) {
        _mounted();
      } else {
        this.bus.$once('page-end', _mounted);
      }
    },
    lifecycle: function lifecycle(name) {
      var _this2 = this;

      var fn = this.options[name];
      utils_type["a" /* default */].Function(fn) && Object(util["g" /* invoke */])(function () {
        return fn(_this2.api);
      });
      this.vm.$emit(name, this.api);
    }
  });
}
// CONCATENATED MODULE: ./packages/form-create/coreSrc/handler/effect.js




function useEffect(Handler) {
  Object(extend["a" /* default */])(Handler.prototype, {
    useProvider: function useProvider() {
      var _this = this;

      var ps = this.fc.providers;
      Object.keys(ps).forEach(function (k) {
        var prop = ps[k];
        prop._c = getComponent(prop);
        _this.onEffect(prop);
        _this.providers[k] = prop;
      });
    },
    onEffect: function onEffect(provider) {
      var _this2 = this;

      var used = [];
      (provider._c || ['*']).forEach(function (name) {
        var type = name === '*' ? '*' : _this2.getType(name);
        if (used.indexOf(type) > -1) return;
        used.push(type);
        _this2.bus.$on('p:' + provider.name + ':' + type + ':' + (provider.input ? 1 : 0), function (event, args) {
          provider[event] && provider[event].apply(provider, args);
        });
      });
      provider._used = used;
    },
    watchEffect: function watchEffect(ctx) {
      var _this3 = this;

      var vm = this.vm;
      Object.keys(ctx.rule.effect || {}).forEach(function (k) {
        ctx.watch.push(vm.$watch(function () {
          return ctx.rule.effect[k];
        }, function (n) {
          var _this3$effect;

          _this3.effect(ctx, 'watch', (_this3$effect = {}, _this3$effect[k] = n, _this3$effect));
        }, { deep: true }));
      });
    },
    effect: function effect(ctx, event, custom) {
      this.emitEffect({
        rule: ctx.rule,
        input: ctx.input,
        type: ctx.trueType,
        ctx: ctx,
        custom: custom
      }, event);
    },
    ruleEffect: function ruleEffect(rule, event) {
      this.emitEffect({
        rule: rule,
        input: !!rule.field,
        type: this.getType(rule.type)
      }, event);
    },
    getEffect: function getEffect(rule, name) {
      if (Object(utils_type["b" /* hasProperty */])(rule, 'effect') && Object(utils_type["b" /* hasProperty */])(rule.effect, name)) {
        return rule.effect[name];
      } else {
        return undefined;
      }
    },
    emitEffect: function emitEffect(_ref, event) {
      var _this4 = this;

      var ctx = _ref.ctx,
          rule = _ref.rule,
          input = _ref.input,
          type = _ref.type,
          custom = _ref.custom;

      if (!type || type === 'fcFragment') return;
      var effect = custom ? custom : rule.effect || {};
      Object.keys(effect).forEach(function (attr) {
        var p = _this4.providers[attr];
        if (!p || p.input && !input) return;
        var _type = void 0;
        if (!p._c) {
          _type = '*';
        } else if (p._used.indexOf(type) > -1) {
          _type = type;
        } else {
          return;
        }
        var data = { value: effect[attr], getValue: function getValue() {
            return _this4.getEffect(rule, attr);
          } };
        if (ctx) {
          data.getProp = function () {
            return ctx.effectData(attr);
          };
          data.clearProp = function () {
            return ctx.clearEffectData(attr);
          };
          data.mergeProp = function (prop) {
            return Object(mergeprops["a" /* default */])([prop], data.getProp());
          };
        }
        _this4.bus.$emit('p:' + attr + ':' + _type + ':' + (p.input ? 1 : 0), event, [data, rule, _this4.api]);
      });
    }
  });
}

function unique(arr) {
  return arr.filter(function (item, index, arr) {
    return arr.indexOf(item, 0) === index;
  });
}

function getComponent(p) {
  var c = p.components;
  if (Array.isArray(c)) return unique(c.filter(function (v) {
    return v !== '*';
  }));else if (utils_type["a" /* default */].String(c)) return [c];else return false;
}
// CONCATENATED MODULE: ./packages/form-create/coreSrc/handler/index.js














function handler_Handler(fc) {
  var _this = this;

  Object(extend["a" /* default */])(this, {
    fc: fc,
    vm: fc.vm,
    watching: false,
    loading: false,
    reloading: false,
    noWatchFn: null,
    deferSyncFn: null,
    isMounted: false,
    formData: {},
    subForm: {},
    form: {},
    appendData: {},
    providers: {},
    cycleLoad: null,
    loadedId: 1,
    nextTick: null,
    changeStatus: false,
    pageEnd: true,
    nextReload: function nextReload() {
      _this.lifecycle('reload');
    }
  });

  Object(util["e" /* funcProxy */])(this, {
    options: function options() {
      return fc.options;
    },
    bus: function bus() {
      return fc.bus;
    }
  });

  this.initData(fc.rules);

  // eslint-disable-next-line new-cap
  this.$manager = new fc.manager(this);
  this.$render = new render_Render(this);
  this.api = fc.extendApi(Api(this), this);
}

Object(extend["a" /* default */])(handler_Handler.prototype, {
  initData: function initData(rules) {
    Object(extend["a" /* default */])(this, {
      fieldCtx: {},
      ctxs: {},
      nameCtx: {},
      sort: [],
      rules: rules,
      repeatRule: []
    });
    useHelper(rules);
  },
  init: function init() {
    this.useProvider();
    this.usePage();
    this.loadRule();
    this.$manager.__init();
    this.vm.$set(this.vm, 'formData', this.formData);
  }
});

useInject(handler_Handler);
page_usePage(handler_Handler);
render_useRender(handler_Handler);
useLoader(handler_Handler);
useInput(handler_Handler);
useContext(handler_Handler);
useLifecycle(handler_Handler);
useEffect(handler_Handler);
// CONCATENATED MODULE: ./packages/form-create/coreSrc/frame/fetch.js

function getError(action, option, xhr) {
  var msg = 'fail to ' + action + ' ' + xhr.status + '\'';
  var err = new Error(msg);
  err.status = xhr.status;
  err.url = action;
  return err;
}

function getBody(xhr) {
  var text = xhr.responseText || xhr.response;
  if (!text) {
    return text;
  }

  try {
    return JSON.parse(text);
  } catch (e) {
    return text;
  }
}

function fetch(option) {
  if (typeof XMLHttpRequest === 'undefined') {
    return;
  }

  var xhr = new XMLHttpRequest();
  var action = option.action;

  var formData = new FormData();

  if (option.data) {
    Object.keys(option.data).map(function (key) {
      formData.append(key, option.data[key]);
    });
  }

  xhr.onerror = function error(e) {
    option.onError(e);
  };

  xhr.onload = function onload() {
    if (xhr.status < 200 || xhr.status >= 300) {
      return option.onError(getError(action, option, xhr), getBody(xhr));
    }

    option.onSuccess(getBody(xhr));
  };

  xhr.open(option.method || 'get', action, true);

  if (option.withCredentials && 'withCredentials' in xhr) {
    xhr.withCredentials = true;
  }

  var headers = option.headers || {};

  Object.keys(headers).forEach(function (item) {
    if (headers[item] !== null) {
      xhr.setRequestHeader(item, headers[item]);
    }
  });
  xhr.send(formData);
}
// CONCATENATED MODULE: ./packages/form-create/coreSrc/components/fragment.js
var fragment_NAME = 'fcFragment';

/* harmony default export */ var fragment = ({
  name: fragment_NAME,
  functional: true,
  render: function render(h, ctx) {
    return ctx.children;
  }
});
// CONCATENATED MODULE: ./packages/form-create/coreSrc/factory/node.js






function parseProp(prop) {
  if (utils_type["a" /* default */].String(prop)) return { domProps: { innerHTML: prop } };
  return prop;
}

function CreateNodeFactory() {
  var aliasMap = {};

  function CreateNode(vm) {
    vm && this.setVm(vm);
  }

  Object(extend["a" /* default */])(CreateNode.prototype, {
    setVm: function setVm(vm) {
      this.vm = vm;
      this.$h = vm.$createElement;
    },
    make: function make(tag, data, children) {
      if (external_vue_default.a.config.isReservedTag(tag) && data.nativeOn) delete data.nativeOn;
      var Node = this.$h(tag, parseProp(data), children || []);
      Node.context = this.vm;
      return Node;
    },

    aliasMap: aliasMap
  });

  Object(extend["a" /* default */])(CreateNode, {
    aliasMap: aliasMap,
    alias: function alias(_alias, name) {
      aliasMap[_alias] = name;
    },
    use: function use(nodes) {
      Object.keys(nodes).forEach(function (k) {
        var line = toLine(k);
        var lower = Object(tostring["a" /* default */])(k).toLocaleLowerCase();
        var v = nodes[k];
        [k, line, lower].forEach(function (n) {
          CreateNode.alias(k, v);
          CreateNode.prototype[n] = function (data, children) {
            return this.make(v, data, children);
          };
        });
      });
    }
  });

  return CreateNode;
}
// CONCATENATED MODULE: ./packages/form-create/coreSrc/factory/manager.js
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }

function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }

/* eslint-disable no-unused-vars */




function createManager(proto) {
  var CustomManager = function (_Manager) {
    _inherits(CustomManager, _Manager);

    function CustomManager() {
      _classCallCheck(this, CustomManager);

      return _possibleConstructorReturn(this, _Manager.apply(this, arguments));
    }

    return CustomManager;
  }(Manager);

  Object.assign(CustomManager.prototype, proto);
  return CustomManager;
}

function Manager(handler) {
  Object(extend["a" /* default */])(this, {
    $handle: handler,
    vm: handler.vm,
    options: {},
    ref: 'fcForm',
    mergeOptionsRule: {
      normal: ['form', 'row', 'info', 'submitBtn', 'resetBtn']
    }
  });
  this.updateKey();
  this.init();
}

Object(extend["a" /* default */])(Manager.prototype, {
  __init: function __init() {
    var _this2 = this;

    this.$render = this.$handle.$render;
    this.$r = function () {
      var _$render;

      return (_$render = _this2.$render).renderRule.apply(_$render, arguments);
    };
  },
  updateKey: function updateKey() {
    this.key = uniqueId();
  },

  // TODO interface
  init: function init() {},
  update: function update() {},
  beforeRender: function beforeRender() {},
  form: function form() {
    return this.vm.$refs[this.ref];
  },
  mergeOptions: function mergeOptions(args, opt) {
    var _this3 = this;

    return Object(mergeprops["a" /* default */])(args.map(function (v) {
      return _this3.tidyOptions(v);
    }), opt, this.mergeOptionsRule);
  },
  updateOptions: function updateOptions(options) {
    this.options = this.mergeOptions([options], this.getDefaultOptions());
    this.update();
  },
  tidyOptions: function tidyOptions(options) {
    return options;
  },
  tidyRule: function tidyRule(ctx) {},
  mergeProp: function mergeProp(ctx) {},
  getDefaultOptions: function getDefaultOptions() {
    return {};
  },
  render: function render(children) {}
});
// CONCATENATED MODULE: ./packages/form-create/coreSrc/frame/provider.js
var provider_extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };

/* eslint-disable one-var */





var $fetch = {
  name: 'fetch',
  loaded: function loaded() {
    run.apply(undefined, arguments);
  },
  watch: function watch(inject, rule, api) {
    if (!run(inject, rule, api)) {
      inject.clearProp();
      api.sync(rule);
    }
  }
};

function parseOpt(option) {
  if (utils_type["a" /* default */].String(option)) {
    option = {
      action: option,
      to: 'options'
    };
  }
  return option;
}

function run(inject, rule, api) {
  var option = inject.value;
  if (!option) return false;
  option = parseOpt(option);
  if (!option.to) {
    return false;
  }
  var _onError = option.onError;

  var check = function check() {
    if (!inject.getValue()) {
      inject.clearProp();
      api.sync(rule);
      return true;
    }
  };

  var set = function set(val) {
    var data = inject.getProp(),
        to = void 0;
    option.to.split('.').forEach(function (v) {
      if (to) {
        data = data[to] = {};
      }
      to = v;
    });
    data[to] = val;
  };

  Object(util["g" /* invoke */])(function () {
    return fetch(provider_extends({}, option, {
      onSuccess: function onSuccess(body) {
        if (check()) return;
        set((option.parse || function (v) {
          return v.data;
        })(body));
        api.sync(rule);
      },
      onError: function onError(e) {
        set(undefined);
        if (check()) return;
        (_onError || function (e) {
          return Object(console["a" /* err */])(e.message || 'fetch fail ' + option.action);
        })(e, rule, api);
      }
    }));
  });

  return true;
}

/* harmony default export */ var provider = ($fetch);
// CONCATENATED MODULE: ./packages/form-create/coreSrc/frame/index.js
var frame_extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };




















var _vue = typeof window !== 'undefined' && window.Vue ? window.Vue : external_vue_default.a;

function _parseProp(name, id) {
  var prop = void 0;
  if (arguments.length === 2) {
    prop = arguments[1];
    id = prop[name];
  } else {
    prop = arguments[2];
  }
  return {
    id: id,
    prop: prop
  };
}

function nameProp() {
  return _parseProp.apply(undefined, ['name'].concat(Array.prototype.slice.call(arguments)));
}

function _getEl(options) {
  if (!options || !options.el) return window.document.body;
  return utils_type["a" /* default */].Element(options.el) ? options.el : document.querySelector(options.el);
}

function mountForm(rules, option) {
  var $vm = new _vue({
    data: function data() {
      // todo 外部无法修改
      return {
        rule: rules,
        option: option || {}
      };
    },
    render: function render(h) {
      return h('FormCreate', {
        ref: 'fc',
        props: this.$data
      });
    }
  });
  $vm.$mount();
  return $vm;
}

function exportAttrs(attrs) {
  var key = attrs.key || [];
  var array = attrs.array || [];
  var normal = attrs.normal || [];
  frame_attrs["c" /* keyAttrs */].push.apply(frame_attrs["c" /* keyAttrs */], key);
  frame_attrs["a" /* arrayAttrs */].push.apply(frame_attrs["a" /* arrayAttrs */], array);
  frame_attrs["d" /* normalAttrs */].push.apply(frame_attrs["d" /* normalAttrs */], normal);

  appendProto([].concat(key, array, normal));
}

// todo 表单嵌套
function FormCreateFactory(config) {
  var _components;

  var components = (_components = {}, _components[fragment.name] = fragment, _components);
  var parsers = {};
  var directives = {};
  var providers = {
    fetch: provider
  };
  var maker = makerFactory();
  var globalConfig = {
    global: {}
  };
  var data = {};
  var CreateNode = CreateNodeFactory();

  exportAttrs(config.attrs || {});

  function directive() {
    var data = nameProp.apply(undefined, arguments);
    if (data.id && data.prop) directives[data.id] = data.prop;
  }

  function register() {
    var data = nameProp.apply(undefined, arguments);
    if (data.id && data.prop) {
      providers[data.id] = frame_extends({}, data.prop, {
        name: data.id
      });
    }
  }

  function componentAlias(alias) {
    CreateNode.use(alias);
  }

  function parser() {
    var data = nameProp.apply(undefined, arguments);
    if (!data.id || !data.prop) return;
    var name = toCase(data.id);
    var parser = data.prop;
    var base = parser.merge === true ? parsers[name] : undefined;
    parsers[name] = frame_extends({}, base || factory_parser, parser);
    maker[name] = creatorFactory(name);
    parser.maker && Object(extend["a" /* default */])(maker, parser.maker);
  }

  function component(id, component) {
    var name = void 0;
    if (utils_type["a" /* default */].String(id)) {
      name = toCase(id);
      if (['form-create', 'formcreate'].indexOf(name) > -1) {
        return $form();
      } else if (component === undefined) {
        return components[name];
      }
    } else {
      name = toCase(id.name);
      component = id;
    }
    if (!name || !component) return;
    components[name] = component;
    if (component.formCreateParser) parser(name, component.formCreateParser);
  }

  function $form() {
    return _vue.extend($FormCreate(FormCreate));
  }

  // todo 检查回调函数作用域
  function use(fn, opt) {
    if (utils_type["a" /* default */].Function(fn.install)) fn.install(create, opt);else if (utils_type["a" /* default */].Function(fn)) fn(create, opt);
    return this;
  }

  function create(rules, _opt, parent) {
    var $vm = mountForm(rules, _opt || {});
    var _this = $vm.$refs.fc.formCreate;
    _this.$parent = parent;
    _getEl(_this.options).appendChild($vm.$el);
    return _this.api();
  }

  function FormCreate(vm, rules, options) {
    Object(extend["a" /* default */])(this, {
      vm: vm,
      manager: createManager(config.manager),
      parsers: parsers,
      providers: providers,
      rules: Array.isArray(rules) ? rules : [],
      prop: {
        components: components,
        directives: directives
      },
      CreateNode: CreateNode,
      bus: new _vue(),
      unwatch: null,
      extendApi: config.extendApi || function (api) {
        return api;
      }
    });
    this.init();
    this.initOptions(options || {});
  }

  Object(extend["a" /* default */])(FormCreate.prototype, {
    init: function init() {
      var _this2 = this;

      var vm = this.vm;
      var h = new handler_Handler(this);
      this.$handle = h;
      vm.$f = h.api;
      vm.$emit('input', h.api);

      vm.$on('hook:created', function () {
        if (_this2.isSub()) {
          _this2.unwatch = vm.$watch(function () {
            return vm.$pfc.option;
          }, function () {
            _this2.initOptions(_this2.options);
            vm.$f.refresh();
          }, {
            deep: true
          });
          _this2.initOptions(_this2.options);
        }
        _this2.created();
      });
      vm.$on('hook:mounted', function () {
        _this2.mounted();
      });
      vm.$on('hook:beforeDestroy', function () {
        vm.destroyed = true;
        _this2.unwatch && _this2.unwatch();
        h.reloadRule([]);
      });
      vm.$on('hook:updated', function () {
        h.bindNextTick(function () {
          return _this2.bus.$emit('next-tick', h.api);
        });
      });
    },
    isSub: function isSub() {
      return this.vm.$pfc && this.vm.extendOption;
    },
    initOptions: function initOptions(options) {
      this.options = frame_extends({
        formData: {},
        submitBtn: {},
        resetBtn: {}
      }, Object(deepextend["a" /* deepCopy */])(globalConfig));
      if (this.isSub()) {
        this.mergeOptions(this.options, this.vm.$pfc.$f.config || {}, true);
      }
      this.updateOptions(options);
    },
    mergeOptions: function mergeOptions(target, opt, parent) {
      opt = Object(deepextend["a" /* deepCopy */])(opt);
      parent && ['page', 'onSubmit', 'mounted', 'reload', 'formData', 'el'].forEach(function (n) {
        delete opt[n];
      });
      if (opt.global) {
        target.global = Object(util["h" /* mergeGlobal */])(target.global, opt.global);
        delete opt.global;
      }
      this.$handle.$manager.mergeOptions([opt], target);
      return target;
    },
    updateOptions: function updateOptions(options) {
      this.mergeOptions(this.options, options);
      this.$handle.$manager.updateOptions(this.options);
    },
    created: function created() {
      this.$handle.init();
    },
    api: function api() {
      return this.$handle.api;
    },
    render: function render() {
      return this.$handle.render();
    },
    mounted: function mounted() {
      this.$handle.mounted();
    }
  });

  function useAttr(formCreate) {
    Object(extend["a" /* default */])(formCreate, {
      version: config.version,
      ui: config.ui,
      data: data,
      maker: maker,
      component: component,
      directive: directive,
      register: register,
      parser: parser,
      use: use,
      componentAlias: componentAlias,
      copyRule: util["b" /* copyRule */],
      copyRules: util["c" /* copyRules */],
      fetch: fetch,
      $form: $form,
      parseJson: util["k" /* parseJson */],
      toJson: util["l" /* toJson */],
      init: function init(rules) {
        var _opt = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};

        // eslint-disable-next-line one-var
        var $vm = mountForm(rules, _opt),
            _this = $vm.$refs.fc.formCreate;
        return {
          mount: function mount($el) {
            if ($el && utils_type["a" /* default */].Element($el)) _this.options.el = $el;
            _getEl(_this.options).appendChild($vm.$el);
            return _this.api();
          },
          remove: function remove() {
            $vm.$el.parentNode && $vm.$el.parentNode.removeChild($vm.$el);
          },
          destroy: function destroy() {
            this.remove();
            $vm.$destroy();
          },

          $f: _this.api()
        };
      }
    });
  }

  function useStatic(formCreate) {
    Object(extend["a" /* default */])(formCreate, {
      create: create,
      install: function install(Vue, options) {
        globalConfig = frame_extends({}, globalConfig, options || {});
        if (Vue._installedFormCreate === true) return;
        Vue._installedFormCreate = true;
        _vue = Vue;

        var $formCreate = function $formCreate(rules) {
          var opt = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};

          return create(rules, opt, this);
        };

        useAttr($formCreate);

        Vue.prototype.$formCreate = $formCreate;
        Vue.component('FormCreate', $form());
      }
    });
  }

  useAttr(create);
  useStatic(create);

  CreateNode.use({
    fragment: 'fcFragment'
  });

  if (config.install) create.use(config);

  return create;
}
// CONCATENATED MODULE: ./packages/form-create/coreSrc/index.js





/* harmony default export */ var coreSrc = __webpack_exports__["b"] = (FormCreateFactory);

/***/ }),
/* 25 */
/***/ (function(module, exports) {

module.exports = require("forever-zu/lib/locale");

/***/ }),
/* 26 */,
/* 27 */
/***/ (function(module, exports) {

module.exports = require("forever-zu/lib/utils/shared");

/***/ }),
/* 28 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "b", function() { return deepExtend; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return deepCopy; });
/* unused harmony export deepExtendArgs */
/* harmony import */ var _modify__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(30);
/* harmony import */ var _type__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(5);



function deepExtend(origin) {
  var target = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
  var mode = arguments[2];

  var isArr = false;
  for (var key in target) {
    if (Object.prototype.hasOwnProperty.call(target, key)) {
      var clone = target[key];
      if ((isArr = Array.isArray(clone)) || _type__WEBPACK_IMPORTED_MODULE_1__[/* default */ "a"].Object(clone)) {
        var nst = origin[key] === undefined;
        if (isArr) {
          isArr = false;
          nst && Object(_modify__WEBPACK_IMPORTED_MODULE_0__[/* $set */ "b"])(origin, key, []);
        } else if (clone._clone && mode !== undefined) {
          if (mode) {
            clone = clone.getRule();
            nst && Object(_modify__WEBPACK_IMPORTED_MODULE_0__[/* $set */ "b"])(origin, key, {});
          } else {
            Object(_modify__WEBPACK_IMPORTED_MODULE_0__[/* $set */ "b"])(origin, key, clone._clone());
            continue;
          }
        } else {
          nst && Object(_modify__WEBPACK_IMPORTED_MODULE_0__[/* $set */ "b"])(origin, key, {});
        }
        origin[key] = deepExtend(origin[key], clone, mode);
      } else {
        Object(_modify__WEBPACK_IMPORTED_MODULE_0__[/* $set */ "b"])(origin, key, clone);
      }
    }
  }
  return mode !== undefined && Array.isArray(origin) ? origin.filter(function (v) {
    return !v || !v.__ctrl;
  }) : origin;
}

function deepCopy(value) {
  return deepExtend({}, { value: value }).value;
}

function deepExtendArgs(origin) {
  for (var _len = arguments.length, lst = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
    lst[_key - 1] = arguments[_key];
  }

  lst.forEach(function (target) {
    origin = deepExtend(origin, target);
  });
  return origin;
}

/***/ }),
/* 29 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "b", function() { return format; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "d", function() { return tip; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return err; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "c", function() { return logError; });
function format(type, msg, rule) {
  return '[form-create ' + type + ']: ' + msg + (rule ? '\n\nrule: ' + JSON.stringify(rule.getRule ? rule.getRule() : rule) : '');
}

function tip(msg, rule) {
  console.warn(format('tip', msg, rule));
}

function err(msg, rule) {
  console.error(format('err', msg, rule));
}

function logError(e) {
  err(e.toString());
  console.error(e);
}

/***/ }),
/* 30 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "b", function() { return $set; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return $del; });
/* harmony import */ var vue__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(9);
/* harmony import */ var vue__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(vue__WEBPACK_IMPORTED_MODULE_0__);


function $set(target, field, value) {
  vue__WEBPACK_IMPORTED_MODULE_0___default.a.set(target, field, value);
}

function $del(target, field) {
  vue__WEBPACK_IMPORTED_MODULE_0___default.a.delete(target, field);
}

/***/ }),
/* 31 */
/***/ (function(module, exports) {

module.exports = require("forever-zu/lib/mixins/focus");

/***/ }),
/* 32 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return toArray; });
function toArray(value) {
  return Array.isArray(value) ? value : [null, undefined, ''].indexOf(value) > -1 ? [] : [value];
}

/***/ }),
/* 33 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";

// CONCATENATED MODULE: ./node_modules/vue-loader/lib/loaders/templateLoader.js??vue-loader-options!./node_modules/vue-loader/lib??vue-loader-options!./packages/select/src/option.vue?vue&type=template&id=7a44c642&
var render = function() {
  var _vm = this
  var _h = _vm.$createElement
  var _c = _vm._self._c || _h
  return _c(
    "li",
    {
      directives: [
        {
          name: "show",
          rawName: "v-show",
          value: _vm.visible,
          expression: "visible"
        }
      ],
      staticClass: "el-select-dropdown__item",
      class: {
        selected: _vm.itemSelected,
        "is-disabled": _vm.disabled || _vm.groupDisabled || _vm.limitReached,
        hover: _vm.hover
      },
      on: {
        mouseenter: _vm.hoverItem,
        click: function($event) {
          $event.stopPropagation()
          return _vm.selectOptionClick($event)
        }
      }
    },
    [_vm._t("default", [_c("span", [_vm._v(_vm._s(_vm.currentLabel))])])],
    2
  )
}
var staticRenderFns = []
render._withStripped = true


// CONCATENATED MODULE: ./packages/select/src/option.vue?vue&type=template&id=7a44c642&

// EXTERNAL MODULE: external "forever-zu/lib/mixins/emitter"
var emitter_ = __webpack_require__(4);
var emitter_default = /*#__PURE__*/__webpack_require__.n(emitter_);

// EXTERNAL MODULE: external "forever-zu/lib/utils/util"
var util_ = __webpack_require__(3);

// CONCATENATED MODULE: ./node_modules/babel-loader/lib!./node_modules/vue-loader/lib??vue-loader-options!./packages/select/src/option.vue?vue&type=script&lang=js&
var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };

//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//




/* harmony default export */ var optionvue_type_script_lang_js_ = ({
  mixins: [emitter_default.a],

  name: 'ElOption',

  componentName: 'ElOption',

  inject: ['select'],

  props: {
    value: {
      required: true
    },
    label: [String, Number],
    created: Boolean,
    disabled: {
      type: Boolean,
      default: false
    }
  },

  data: function data() {
    return {
      index: -1,
      groupDisabled: false,
      visible: true,
      hitState: false,
      hover: false
    };
  },


  computed: {
    isObject: function isObject() {
      return Object.prototype.toString.call(this.value).toLowerCase() === '[object object]';
    },
    currentLabel: function currentLabel() {
      return this.label || (this.isObject ? '' : this.value);
    },
    currentValue: function currentValue() {
      return this.value || this.label || '';
    },
    itemSelected: function itemSelected() {
      if (!this.select.multiple) {
        return this.isEqual(this.value, this.select.value);
      } else {
        return this.contains(this.select.value, this.value);
      }
    },
    limitReached: function limitReached() {
      if (this.select.multiple) {
        return !this.itemSelected && (this.select.value || []).length >= this.select.multipleLimit && this.select.multipleLimit > 0;
      } else {
        return false;
      }
    }
  },

  watch: {
    currentLabel: function currentLabel() {
      if (!this.created && !this.select.remote) this.dispatch('ElSelect', 'setSelected');
    },
    value: function value(val, oldVal) {
      var _select = this.select,
          remote = _select.remote,
          valueKey = _select.valueKey;

      if (!this.created && !remote) {
        if (valueKey && (typeof val === 'undefined' ? 'undefined' : _typeof(val)) === 'object' && (typeof oldVal === 'undefined' ? 'undefined' : _typeof(oldVal)) === 'object' && val[valueKey] === oldVal[valueKey]) {
          return;
        }
        this.dispatch('ElSelect', 'setSelected');
      }
    }
  },

  methods: {
    isEqual: function isEqual(a, b) {
      if (!this.isObject) {
        return a === b;
      } else {
        var valueKey = this.select.valueKey;
        return Object(util_["getValueByPath"])(a, valueKey) === Object(util_["getValueByPath"])(b, valueKey);
      }
    },
    contains: function contains() {
      var arr = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
      var target = arguments[1];

      if (!this.isObject) {
        return arr && arr.indexOf(target) > -1;
      } else {
        var valueKey = this.select.valueKey;
        return arr && arr.some(function (item) {
          return Object(util_["getValueByPath"])(item, valueKey) === Object(util_["getValueByPath"])(target, valueKey);
        });
      }
    },
    handleGroupDisabled: function handleGroupDisabled(val) {
      this.groupDisabled = val;
    },
    hoverItem: function hoverItem() {
      if (!this.disabled && !this.groupDisabled) {
        this.select.hoverIndex = this.select.options.indexOf(this);
      }
    },
    selectOptionClick: function selectOptionClick() {
      if (this.disabled !== true && this.groupDisabled !== true) {
        this.dispatch('ElSelect', 'handleOptionClick', [this, true]);
      }
    },
    queryChange: function queryChange(query) {
      this.visible = new RegExp(Object(util_["escapeRegexpString"])(query), 'i').test(this.currentLabel) || this.created;
      if (!this.visible) {
        this.select.filteredOptionsCount--;
      }
    }
  },

  created: function created() {
    this.select.options.push(this);
    this.select.cachedOptions.push(this);
    this.select.optionsCount++;
    this.select.filteredOptionsCount++;

    this.$on('queryChange', this.queryChange);
    this.$on('handleGroupDisabled', this.handleGroupDisabled);
  },
  beforeDestroy: function beforeDestroy() {
    var _select2 = this.select,
        selected = _select2.selected,
        multiple = _select2.multiple;

    var selectedOptions = multiple ? selected : [selected];
    var index = this.select.cachedOptions.indexOf(this);
    var selectedIndex = selectedOptions.indexOf(this);

    // if option is not selected, remove it from cache
    if (index > -1 && selectedIndex < 0) {
      this.select.cachedOptions.splice(index, 1);
    }
    this.select.onOptionDestroy(this.select.options.indexOf(this));
  }
});
// CONCATENATED MODULE: ./packages/select/src/option.vue?vue&type=script&lang=js&
 /* harmony default export */ var src_optionvue_type_script_lang_js_ = (optionvue_type_script_lang_js_); 
// EXTERNAL MODULE: ./node_modules/vue-loader/lib/runtime/componentNormalizer.js
var componentNormalizer = __webpack_require__(0);

// CONCATENATED MODULE: ./packages/select/src/option.vue





/* normalize component */

var component = Object(componentNormalizer["a" /* default */])(
  src_optionvue_type_script_lang_js_,
  render,
  staticRenderFns,
  false,
  null,
  null,
  null
  
)

/* hot reload */
if (false) { var api; }
component.options.__file = "packages/select/src/option.vue"
/* harmony default export */ var src_option = __webpack_exports__["a"] = (component.exports);

/***/ }),
/* 34 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "c", function() { return keyAttrs; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return arrayAttrs; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "d", function() { return normalAttrs; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "b", function() { return attrs; });
/* harmony import */ var packages_form_create_utils_mergeprops__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(23);


var keyAttrs = ['type', 'slot', 'emitPrefix', 'value', 'name', 'native', 'hidden', 'display', 'inject', 'options', 'emit', 'nativeEmit', 'link', 'prefix', 'suffix', 'update', 'sync'];

var arrayAttrs = ['validate', 'children', 'control'];

var normalAttrs = ['effect'];

function attrs() {
  return [].concat(keyAttrs, packages_form_create_utils_mergeprops__WEBPACK_IMPORTED_MODULE_0__[/* normalMerge */ "c"], packages_form_create_utils_mergeprops__WEBPACK_IMPORTED_MODULE_0__[/* toArrayMerge */ "d"], packages_form_create_utils_mergeprops__WEBPACK_IMPORTED_MODULE_0__[/* functionalMerge */ "b"], arrayAttrs, normalAttrs);
}

/***/ }),
/* 35 */
/***/ (function(module, exports) {

module.exports = require("forever-zu/lib/transitions/collapse-transition");

/***/ }),
/* 36 */
/***/ (function(module, exports) {

module.exports = require("forever-zu/lib/utils/scroll-into-view");

/***/ }),
/* 37 */,
/* 38 */,
/* 39 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return getSlot; });
function getSlot(slots, exclude) {
  return Object.keys(slots).reduce(function (lst, name) {
    if (!exclude || exclude.indexOf(name) === -1) {
      lst.push(slots[name]);
    }
    return lst;
  }, []);
}

/***/ }),
/* 40 */
/***/ (function(module, exports) {

module.exports = require("forever-zu/lib/progress");

/***/ }),
/* 41 */,
/* 42 */,
/* 43 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";

// CONCATENATED MODULE: ./node_modules/vue-loader/lib/loaders/templateLoader.js??vue-loader-options!./node_modules/vue-loader/lib??vue-loader-options!./packages/select/src/select.vue?vue&type=template&id=0e4aade6&
var render = function() {
  var _vm = this
  var _h = _vm.$createElement
  var _c = _vm._self._c || _h
  return _c(
    "div",
    {
      directives: [
        {
          name: "clickoutside",
          rawName: "v-clickoutside",
          value: _vm.handleClose,
          expression: "handleClose"
        }
      ],
      staticClass: "el-select",
      class: [_vm.selectSize ? "el-select--" + _vm.selectSize : ""],
      on: {
        click: function($event) {
          $event.stopPropagation()
          return _vm.toggleMenu($event)
        }
      }
    },
    [
      _vm.multiple
        ? _c(
            "div",
            {
              ref: "tags",
              staticClass: "el-select__tags",
              style: { "max-width": _vm.inputWidth - 32 + "px", width: "100%" }
            },
            [
              _vm.collapseTags && _vm.selected.length
                ? _c(
                    "span",
                    [
                      _c(
                        "el-tag",
                        {
                          attrs: {
                            closable: !_vm.selectDisabled,
                            size: _vm.collapseTagSize,
                            hit: _vm.selected[0].hitState,
                            type: "info",
                            "disable-transitions": ""
                          },
                          on: {
                            close: function($event) {
                              _vm.deleteTag($event, _vm.selected[0])
                            }
                          }
                        },
                        [
                          _c("span", { staticClass: "el-select__tags-text" }, [
                            _vm._v(_vm._s(_vm.selected[0].currentLabel))
                          ])
                        ]
                      ),
                      _vm.selected.length > 1
                        ? _c(
                            "el-tag",
                            {
                              attrs: {
                                closable: false,
                                size: _vm.collapseTagSize,
                                type: "info",
                                "disable-transitions": ""
                              }
                            },
                            [
                              _c(
                                "span",
                                { staticClass: "el-select__tags-text" },
                                [_vm._v("+ " + _vm._s(_vm.selected.length - 1))]
                              )
                            ]
                          )
                        : _vm._e()
                    ],
                    1
                  )
                : _vm._e(),
              !_vm.collapseTags
                ? _c(
                    "transition-group",
                    { on: { "after-leave": _vm.resetInputHeight } },
                    _vm._l(_vm.selected, function(item) {
                      return _c(
                        "el-tag",
                        {
                          key: _vm.getValueKey(item),
                          attrs: {
                            closable: !_vm.selectDisabled,
                            size: _vm.collapseTagSize,
                            hit: item.hitState,
                            type: "info",
                            "disable-transitions": ""
                          },
                          on: {
                            close: function($event) {
                              _vm.deleteTag($event, item)
                            }
                          }
                        },
                        [
                          _c("span", { staticClass: "el-select__tags-text" }, [
                            _vm._v(_vm._s(item.currentLabel))
                          ])
                        ]
                      )
                    }),
                    1
                  )
                : _vm._e(),
              _vm.filterable
                ? _c("input", {
                    directives: [
                      {
                        name: "model",
                        rawName: "v-model",
                        value: _vm.query,
                        expression: "query"
                      }
                    ],
                    ref: "input",
                    staticClass: "el-select__input",
                    class: [_vm.selectSize ? "is-" + _vm.selectSize : ""],
                    style: {
                      "flex-grow": "1",
                      width: _vm.inputLength / (_vm.inputWidth - 32) + "%",
                      "max-width": _vm.inputWidth - 42 + "px"
                    },
                    attrs: {
                      type: "text",
                      disabled: _vm.selectDisabled,
                      autocomplete: _vm.autoComplete || _vm.autocomplete
                    },
                    domProps: { value: _vm.query },
                    on: {
                      focus: _vm.handleFocus,
                      blur: function($event) {
                        _vm.softFocus = false
                      },
                      keyup: _vm.managePlaceholder,
                      keydown: [
                        _vm.resetInputState,
                        function($event) {
                          if (
                            !("button" in $event) &&
                            _vm._k($event.keyCode, "down", 40, $event.key, [
                              "Down",
                              "ArrowDown"
                            ])
                          ) {
                            return null
                          }
                          $event.preventDefault()
                          _vm.navigateOptions("next")
                        },
                        function($event) {
                          if (
                            !("button" in $event) &&
                            _vm._k($event.keyCode, "up", 38, $event.key, [
                              "Up",
                              "ArrowUp"
                            ])
                          ) {
                            return null
                          }
                          $event.preventDefault()
                          _vm.navigateOptions("prev")
                        },
                        function($event) {
                          if (
                            !("button" in $event) &&
                            _vm._k(
                              $event.keyCode,
                              "enter",
                              13,
                              $event.key,
                              "Enter"
                            )
                          ) {
                            return null
                          }
                          $event.preventDefault()
                          return _vm.selectOption($event)
                        },
                        function($event) {
                          if (
                            !("button" in $event) &&
                            _vm._k($event.keyCode, "esc", 27, $event.key, [
                              "Esc",
                              "Escape"
                            ])
                          ) {
                            return null
                          }
                          $event.stopPropagation()
                          $event.preventDefault()
                          _vm.visible = false
                        },
                        function($event) {
                          if (
                            !("button" in $event) &&
                            _vm._k(
                              $event.keyCode,
                              "delete",
                              [8, 46],
                              $event.key,
                              ["Backspace", "Delete", "Del"]
                            )
                          ) {
                            return null
                          }
                          return _vm.deletePrevTag($event)
                        },
                        function($event) {
                          if (
                            !("button" in $event) &&
                            _vm._k($event.keyCode, "tab", 9, $event.key, "Tab")
                          ) {
                            return null
                          }
                          _vm.visible = false
                        }
                      ],
                      compositionstart: _vm.handleComposition,
                      compositionupdate: _vm.handleComposition,
                      compositionend: _vm.handleComposition,
                      input: [
                        function($event) {
                          if ($event.target.composing) {
                            return
                          }
                          _vm.query = $event.target.value
                        },
                        _vm.debouncedQueryChange
                      ]
                    }
                  })
                : _vm._e()
            ],
            1
          )
        : _vm._e(),
      _c(
        "el-input",
        {
          ref: "reference",
          class: { "is-focus": _vm.visible },
          attrs: {
            type: "text",
            placeholder: _vm.currentPlaceholder,
            name: _vm.name,
            id: _vm.id,
            autocomplete: _vm.autoComplete || _vm.autocomplete,
            size: _vm.selectSize,
            disabled: _vm.selectDisabled,
            readonly: _vm.readonly,
            "validate-event": false,
            tabindex: _vm.multiple && _vm.filterable ? "-1" : null
          },
          on: { focus: _vm.handleFocus, blur: _vm.handleBlur },
          nativeOn: {
            keyup: function($event) {
              return _vm.debouncedOnInputChange($event)
            },
            keydown: [
              function($event) {
                if (
                  !("button" in $event) &&
                  _vm._k($event.keyCode, "down", 40, $event.key, [
                    "Down",
                    "ArrowDown"
                  ])
                ) {
                  return null
                }
                $event.stopPropagation()
                $event.preventDefault()
                _vm.navigateOptions("next")
              },
              function($event) {
                if (
                  !("button" in $event) &&
                  _vm._k($event.keyCode, "up", 38, $event.key, [
                    "Up",
                    "ArrowUp"
                  ])
                ) {
                  return null
                }
                $event.stopPropagation()
                $event.preventDefault()
                _vm.navigateOptions("prev")
              },
              function($event) {
                if (
                  !("button" in $event) &&
                  _vm._k($event.keyCode, "enter", 13, $event.key, "Enter")
                ) {
                  return null
                }
                $event.preventDefault()
                return _vm.selectOption($event)
              },
              function($event) {
                if (
                  !("button" in $event) &&
                  _vm._k($event.keyCode, "esc", 27, $event.key, [
                    "Esc",
                    "Escape"
                  ])
                ) {
                  return null
                }
                $event.stopPropagation()
                $event.preventDefault()
                _vm.visible = false
              },
              function($event) {
                if (
                  !("button" in $event) &&
                  _vm._k($event.keyCode, "tab", 9, $event.key, "Tab")
                ) {
                  return null
                }
                _vm.visible = false
              }
            ],
            paste: function($event) {
              return _vm.debouncedOnInputChange($event)
            },
            mouseenter: function($event) {
              _vm.inputHovering = true
            },
            mouseleave: function($event) {
              _vm.inputHovering = false
            }
          },
          model: {
            value: _vm.selectedLabel,
            callback: function($$v) {
              _vm.selectedLabel = $$v
            },
            expression: "selectedLabel"
          }
        },
        [
          _vm.$slots.prefix
            ? _c("template", { slot: "prefix" }, [_vm._t("prefix")], 2)
            : _vm._e(),
          _c("template", { slot: "suffix" }, [
            _c("i", {
              directives: [
                {
                  name: "show",
                  rawName: "v-show",
                  value: !_vm.showClose,
                  expression: "!showClose"
                }
              ],
              class: [
                "el-select__caret",
                "el-input__icon",
                "el-icon-" + _vm.iconClass
              ]
            }),
            _vm.showClose
              ? _c("i", {
                  staticClass:
                    "el-select__caret el-input__icon el-icon-circle-close",
                  on: { click: _vm.handleClearClick }
                })
              : _vm._e()
          ])
        ],
        2
      ),
      _c(
        "transition",
        {
          attrs: { name: "el-zoom-in-top" },
          on: {
            "before-enter": _vm.handleMenuEnter,
            "after-leave": _vm.doDestroy
          }
        },
        [
          _c(
            "el-select-menu",
            {
              directives: [
                {
                  name: "show",
                  rawName: "v-show",
                  value: _vm.visible && _vm.emptyText !== false,
                  expression: "visible && emptyText !== false"
                }
              ],
              ref: "popper",
              attrs: { "append-to-body": _vm.popperAppendToBody }
            },
            [
              _c(
                "el-scrollbar",
                {
                  directives: [
                    {
                      name: "show",
                      rawName: "v-show",
                      value: _vm.options.length > 0 && !_vm.loading,
                      expression: "options.length > 0 && !loading"
                    }
                  ],
                  ref: "scrollbar",
                  class: {
                    "is-empty":
                      !_vm.allowCreate &&
                      _vm.query &&
                      _vm.filteredOptionsCount === 0
                  },
                  attrs: {
                    tag: "ul",
                    "wrap-class": "el-select-dropdown__wrap",
                    "view-class": "el-select-dropdown__list"
                  }
                },
                [
                  _vm.showNewOption
                    ? _c("el-option", {
                        attrs: { value: _vm.query, created: "" }
                      })
                    : _vm._e(),
                  _vm._t("default")
                ],
                2
              ),
              _vm.emptyText &&
              (!_vm.allowCreate ||
                _vm.loading ||
                (_vm.allowCreate && _vm.options.length === 0))
                ? [
                    _vm.$slots.empty
                      ? _vm._t("empty")
                      : _c("p", { staticClass: "el-select-dropdown__empty" }, [
                          _vm._v(
                            "\n          " +
                              _vm._s(_vm.emptyText) +
                              "\n        "
                          )
                        ])
                  ]
                : _vm._e()
            ],
            2
          )
        ],
        1
      )
    ],
    1
  )
}
var staticRenderFns = []
render._withStripped = true


// CONCATENATED MODULE: ./packages/select/src/select.vue?vue&type=template&id=0e4aade6&

// EXTERNAL MODULE: external "forever-zu/lib/mixins/emitter"
var emitter_ = __webpack_require__(4);
var emitter_default = /*#__PURE__*/__webpack_require__.n(emitter_);

// EXTERNAL MODULE: external "forever-zu/lib/mixins/focus"
var focus_ = __webpack_require__(31);
var focus_default = /*#__PURE__*/__webpack_require__.n(focus_);

// EXTERNAL MODULE: external "forever-zu/lib/mixins/locale"
var locale_ = __webpack_require__(8);
var locale_default = /*#__PURE__*/__webpack_require__.n(locale_);

// EXTERNAL MODULE: external "forever-zu/lib/input"
var input_ = __webpack_require__(13);
var input_default = /*#__PURE__*/__webpack_require__.n(input_);

// CONCATENATED MODULE: ./node_modules/vue-loader/lib/loaders/templateLoader.js??vue-loader-options!./node_modules/vue-loader/lib??vue-loader-options!./packages/select/src/select-dropdown.vue?vue&type=template&id=06828748&
var select_dropdownvue_type_template_id_06828748_render = function() {
  var _vm = this
  var _h = _vm.$createElement
  var _c = _vm._self._c || _h
  return _c(
    "div",
    {
      staticClass: "el-select-dropdown el-popper",
      class: [{ "is-multiple": _vm.$parent.multiple }, _vm.popperClass],
      style: { minWidth: _vm.minWidth }
    },
    [_vm._t("default")],
    2
  )
}
var select_dropdownvue_type_template_id_06828748_staticRenderFns = []
select_dropdownvue_type_template_id_06828748_render._withStripped = true


// CONCATENATED MODULE: ./packages/select/src/select-dropdown.vue?vue&type=template&id=06828748&

// EXTERNAL MODULE: external "forever-zu/lib/utils/vue-popper"
var vue_popper_ = __webpack_require__(6);
var vue_popper_default = /*#__PURE__*/__webpack_require__.n(vue_popper_);

// CONCATENATED MODULE: ./node_modules/babel-loader/lib!./node_modules/vue-loader/lib??vue-loader-options!./packages/select/src/select-dropdown.vue?vue&type=script&lang=js&
//
//
//
//
//
//
//
//
//



/* harmony default export */ var select_dropdownvue_type_script_lang_js_ = ({
  name: 'ElSelectDropdown',

  componentName: 'ElSelectDropdown',

  mixins: [vue_popper_default.a],

  props: {
    placement: {
      default: 'bottom-start'
    },

    boundariesPadding: {
      default: 0
    },

    popperOptions: {
      default: function _default() {
        return {
          gpuAcceleration: false
        };
      }
    },

    visibleArrow: {
      default: true
    },

    appendToBody: {
      type: Boolean,
      default: true
    }
  },

  data: function data() {
    return {
      minWidth: ''
    };
  },


  computed: {
    popperClass: function popperClass() {
      return this.$parent.popperClass;
    }
  },

  watch: {
    '$parent.inputWidth': function $parentInputWidth() {
      this.minWidth = this.$parent.$el.getBoundingClientRect().width + 'px';
    }
  },

  mounted: function mounted() {
    var _this = this;

    this.referenceElm = this.$parent.$refs.reference.$el;
    this.$parent.popperElm = this.popperElm = this.$el;
    this.$on('updatePopper', function () {
      if (_this.$parent.visible) _this.updatePopper();
    });
    this.$on('destroyPopper', this.destroyPopper);
  }
});
// CONCATENATED MODULE: ./packages/select/src/select-dropdown.vue?vue&type=script&lang=js&
 /* harmony default export */ var src_select_dropdownvue_type_script_lang_js_ = (select_dropdownvue_type_script_lang_js_); 
// EXTERNAL MODULE: ./node_modules/vue-loader/lib/runtime/componentNormalizer.js
var componentNormalizer = __webpack_require__(0);

// CONCATENATED MODULE: ./packages/select/src/select-dropdown.vue





/* normalize component */

var component = Object(componentNormalizer["a" /* default */])(
  src_select_dropdownvue_type_script_lang_js_,
  select_dropdownvue_type_template_id_06828748_render,
  select_dropdownvue_type_template_id_06828748_staticRenderFns,
  false,
  null,
  null,
  null
  
)

/* hot reload */
if (false) { var api; }
component.options.__file = "packages/select/src/select-dropdown.vue"
/* harmony default export */ var select_dropdown = (component.exports);
// EXTERNAL MODULE: ./packages/select/src/option.vue + 4 modules
var src_option = __webpack_require__(33);

// EXTERNAL MODULE: external "forever-zu/lib/tag"
var tag_ = __webpack_require__(46);
var tag_default = /*#__PURE__*/__webpack_require__.n(tag_);

// EXTERNAL MODULE: external "forever-zu/lib/scrollbar"
var scrollbar_ = __webpack_require__(17);
var scrollbar_default = /*#__PURE__*/__webpack_require__.n(scrollbar_);

// EXTERNAL MODULE: external "throttle-debounce/debounce"
var debounce_ = __webpack_require__(19);
var debounce_default = /*#__PURE__*/__webpack_require__.n(debounce_);

// EXTERNAL MODULE: external "forever-zu/lib/utils/clickoutside"
var clickoutside_ = __webpack_require__(15);
var clickoutside_default = /*#__PURE__*/__webpack_require__.n(clickoutside_);

// EXTERNAL MODULE: external "forever-zu/lib/utils/resize-event"
var resize_event_ = __webpack_require__(16);

// EXTERNAL MODULE: external "forever-zu/lib/utils/scroll-into-view"
var scroll_into_view_ = __webpack_require__(36);
var scroll_into_view_default = /*#__PURE__*/__webpack_require__.n(scroll_into_view_);

// EXTERNAL MODULE: external "forever-zu/lib/utils/util"
var util_ = __webpack_require__(3);

// CONCATENATED MODULE: ./packages/select/src/navigation-mixin.js
/* harmony default export */ var navigation_mixin = ({
  data: function data() {
    return {
      hoverOption: -1
    };
  },


  computed: {
    optionsAllDisabled: function optionsAllDisabled() {
      return this.options.filter(function (option) {
        return option.visible;
      }).every(function (option) {
        return option.disabled;
      });
    }
  },

  watch: {
    hoverIndex: function hoverIndex(val) {
      var _this = this;

      if (typeof val === 'number' && val > -1) {
        this.hoverOption = this.options[val] || {};
      }
      this.options.forEach(function (option) {
        option.hover = _this.hoverOption === option;
      });
    }
  },

  methods: {
    navigateOptions: function navigateOptions(direction) {
      var _this2 = this;

      if (!this.visible) {
        this.visible = true;
        return;
      }
      if (this.options.length === 0 || this.filteredOptionsCount === 0) return;
      if (!this.optionsAllDisabled) {
        if (direction === 'next') {
          this.hoverIndex++;
          if (this.hoverIndex === this.options.length) {
            this.hoverIndex = 0;
          }
        } else if (direction === 'prev') {
          this.hoverIndex--;
          if (this.hoverIndex < 0) {
            this.hoverIndex = this.options.length - 1;
          }
        }
        var option = this.options[this.hoverIndex];
        if (option.disabled === true || option.groupDisabled === true || !option.visible) {
          this.navigateOptions(direction);
        }
        this.$nextTick(function () {
          return _this2.scrollToOption(_this2.hoverOption);
        });
      }
    }
  }
});
// EXTERNAL MODULE: external "forever-zu/lib/utils/shared"
var shared_ = __webpack_require__(27);

// CONCATENATED MODULE: ./node_modules/babel-loader/lib!./node_modules/vue-loader/lib??vue-loader-options!./packages/select/src/select.vue?vue&type=script&lang=js&
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//

















/* harmony default export */ var selectvue_type_script_lang_js_ = ({
  mixins: [emitter_default.a, locale_default.a, focus_default()('reference'), navigation_mixin],

  name: 'ElSelect',

  componentName: 'ElSelect',

  inject: {
    elForm: {
      default: ''
    },

    elFormItem: {
      default: ''
    }
  },

  provide: function provide() {
    return {
      'select': this
    };
  },


  computed: {
    _elFormItemSize: function _elFormItemSize() {
      return (this.elFormItem || {}).elFormItemSize;
    },
    readonly: function readonly() {
      return !this.filterable || this.multiple || !Object(util_["isIE"])() && !Object(util_["isEdge"])() && !this.visible;
    },
    showClose: function showClose() {
      var hasValue = this.multiple ? Array.isArray(this.value) && this.value.length > 0 : this.value !== undefined && this.value !== null && this.value !== '';
      var criteria = this.clearable && !this.selectDisabled && this.inputHovering && hasValue;
      return criteria;
    },
    iconClass: function iconClass() {
      return this.remote && this.filterable ? '' : this.visible ? 'arrow-up is-reverse' : 'arrow-up';
    },
    debounce: function debounce() {
      return this.remote ? 300 : 0;
    },
    emptyText: function emptyText() {
      if (this.loading) {
        return this.loadingText || this.t('el.select.loading');
      } else {
        if (this.remote && this.query === '' && this.options.length === 0) return false;
        if (this.filterable && this.query && this.options.length > 0 && this.filteredOptionsCount === 0) {
          return this.noMatchText || this.t('el.select.noMatch');
        }
        if (this.options.length === 0) {
          return this.noDataText || this.t('el.select.noData');
        }
      }
      return null;
    },
    showNewOption: function showNewOption() {
      var _this = this;

      var hasExistingOption = this.options.filter(function (option) {
        return !option.created;
      }).some(function (option) {
        return option.currentLabel === _this.query;
      });
      return this.filterable && this.allowCreate && this.query !== '' && !hasExistingOption;
    },
    selectSize: function selectSize() {
      return this.size || this._elFormItemSize || (this.$ELEMENT || {}).size;
    },
    selectDisabled: function selectDisabled() {
      return this.disabled || (this.elForm || {}).disabled;
    },
    collapseTagSize: function collapseTagSize() {
      return ['small', 'mini'].indexOf(this.selectSize) > -1 ? 'mini' : 'small';
    },
    propPlaceholder: function propPlaceholder() {
      return typeof this.placeholder !== 'undefined' ? this.placeholder : this.t('el.select.placeholder');
    }
  },

  components: {
    ElInput: input_default.a,
    ElSelectMenu: select_dropdown,
    ElOption: src_option["a" /* default */],
    ElTag: tag_default.a,
    ElScrollbar: scrollbar_default.a
  },

  directives: { Clickoutside: clickoutside_default.a },

  props: {
    name: String,
    id: String,
    value: {
      required: true
    },
    autocomplete: {
      type: String,
      default: 'off'
    },
    /** @Deprecated in next major version */
    autoComplete: {
      type: String,
      validator: function validator(val) {
         false && false;
        return true;
      }
    },
    automaticDropdown: Boolean,
    size: String,
    disabled: Boolean,
    clearable: Boolean,
    filterable: Boolean,
    allowCreate: Boolean,
    loading: Boolean,
    popperClass: String,
    remote: Boolean,
    loadingText: String,
    noMatchText: String,
    noDataText: String,
    remoteMethod: Function,
    filterMethod: Function,
    multiple: Boolean,
    multipleLimit: {
      type: Number,
      default: 0
    },
    placeholder: {
      type: String,
      required: false
    },
    defaultFirstOption: Boolean,
    reserveKeyword: Boolean,
    valueKey: {
      type: String,
      default: 'value'
    },
    collapseTags: Boolean,
    popperAppendToBody: {
      type: Boolean,
      default: true
    }
  },

  data: function data() {
    return {
      options: [],
      cachedOptions: [],
      createdLabel: null,
      createdSelected: false,
      selected: this.multiple ? [] : {},
      inputLength: 20,
      inputWidth: 0,
      initialInputHeight: 0,
      cachedPlaceHolder: '',
      optionsCount: 0,
      filteredOptionsCount: 0,
      visible: false,
      softFocus: false,
      selectedLabel: '',
      hoverIndex: -1,
      query: '',
      previousQuery: null,
      inputHovering: false,
      currentPlaceholder: '',
      menuVisibleOnFocus: false,
      isOnComposition: false,
      isSilentBlur: false
    };
  },


  watch: {
    selectDisabled: function selectDisabled() {
      var _this2 = this;

      this.$nextTick(function () {
        _this2.resetInputHeight();
      });
    },
    propPlaceholder: function propPlaceholder(val) {
      this.cachedPlaceHolder = this.currentPlaceholder = val;
    },
    value: function value(val, oldVal) {
      if (this.multiple) {
        this.resetInputHeight();
        if (val && val.length > 0 || this.$refs.input && this.query !== '') {
          this.currentPlaceholder = '';
        } else {
          this.currentPlaceholder = this.cachedPlaceHolder;
        }
        if (this.filterable && !this.reserveKeyword) {
          this.query = '';
          this.handleQueryChange(this.query);
        }
      }
      this.setSelected();
      if (this.filterable && !this.multiple) {
        this.inputLength = 20;
      }
      if (!Object(util_["valueEquals"])(val, oldVal)) {
        this.dispatch('ElFormItem', 'el.form.change', val);
      }
    },
    visible: function visible(val) {
      var _this3 = this;

      if (!val) {
        this.broadcast('ElSelectDropdown', 'destroyPopper');
        if (this.$refs.input) {
          this.$refs.input.blur();
        }
        this.query = '';
        this.previousQuery = null;
        this.selectedLabel = '';
        this.inputLength = 20;
        this.menuVisibleOnFocus = false;
        this.resetHoverIndex();
        this.$nextTick(function () {
          if (_this3.$refs.input && _this3.$refs.input.value === '' && _this3.selected.length === 0) {
            _this3.currentPlaceholder = _this3.cachedPlaceHolder;
          }
        });
        if (!this.multiple) {
          if (this.selected) {
            if (this.filterable && this.allowCreate && this.createdSelected && this.createdLabel) {
              this.selectedLabel = this.createdLabel;
            } else {
              this.selectedLabel = this.selected.currentLabel;
            }
            if (this.filterable) this.query = this.selectedLabel;
          }

          if (this.filterable) {
            this.currentPlaceholder = this.cachedPlaceHolder;
          }
        }
      } else {
        this.broadcast('ElSelectDropdown', 'updatePopper');
        if (this.filterable) {
          this.query = this.remote ? '' : this.selectedLabel;
          this.handleQueryChange(this.query);
          if (this.multiple) {
            this.$refs.input.focus();
          } else {
            if (!this.remote) {
              this.broadcast('ElOption', 'queryChange', '');
              this.broadcast('ElOptionGroup', 'queryChange');
            }

            if (this.selectedLabel) {
              this.currentPlaceholder = this.selectedLabel;
              this.selectedLabel = '';
            }
          }
        }
      }
      this.$emit('visible-change', val);
    },
    options: function options() {
      var _this4 = this;

      if (this.$isServer) return;
      this.$nextTick(function () {
        _this4.broadcast('ElSelectDropdown', 'updatePopper');
      });
      if (this.multiple) {
        this.resetInputHeight();
      }
      var inputs = this.$el.querySelectorAll('input');
      if ([].indexOf.call(inputs, document.activeElement) === -1) {
        this.setSelected();
      }
      if (this.defaultFirstOption && (this.filterable || this.remote) && this.filteredOptionsCount) {
        this.checkDefaultFirstOption();
      }
    }
  },

  methods: {
    handleComposition: function handleComposition(event) {
      var _this5 = this;

      var text = event.target.value;
      if (event.type === 'compositionend') {
        this.isOnComposition = false;
        this.$nextTick(function (_) {
          return _this5.handleQueryChange(text);
        });
      } else {
        var lastCharacter = text[text.length - 1] || '';
        this.isOnComposition = !Object(shared_["isKorean"])(lastCharacter);
      }
    },
    handleQueryChange: function handleQueryChange(val) {
      var _this6 = this;

      if (this.previousQuery === val || this.isOnComposition) return;
      if (this.previousQuery === null && (typeof this.filterMethod === 'function' || typeof this.remoteMethod === 'function')) {
        this.previousQuery = val;
        return;
      }
      this.previousQuery = val;
      this.$nextTick(function () {
        if (_this6.visible) _this6.broadcast('ElSelectDropdown', 'updatePopper');
      });
      this.hoverIndex = -1;
      if (this.multiple && this.filterable) {
        this.$nextTick(function () {
          var length = _this6.$refs.input.value.length * 15 + 20;
          _this6.inputLength = _this6.collapseTags ? Math.min(50, length) : length;
          _this6.managePlaceholder();
          _this6.resetInputHeight();
        });
      }
      if (this.remote && typeof this.remoteMethod === 'function') {
        this.hoverIndex = -1;
        this.remoteMethod(val);
      } else if (typeof this.filterMethod === 'function') {
        this.filterMethod(val);
        this.broadcast('ElOptionGroup', 'queryChange');
      } else {
        this.filteredOptionsCount = this.optionsCount;
        this.broadcast('ElOption', 'queryChange', val);
        this.broadcast('ElOptionGroup', 'queryChange');
      }
      if (this.defaultFirstOption && (this.filterable || this.remote) && this.filteredOptionsCount) {
        this.checkDefaultFirstOption();
      }
    },
    scrollToOption: function scrollToOption(option) {
      var target = Array.isArray(option) && option[0] ? option[0].$el : option.$el;
      if (this.$refs.popper && target) {
        var menu = this.$refs.popper.$el.querySelector('.el-select-dropdown__wrap');
        scroll_into_view_default()(menu, target);
      }
      this.$refs.scrollbar && this.$refs.scrollbar.handleScroll();
    },
    handleMenuEnter: function handleMenuEnter() {
      var _this7 = this;

      this.$nextTick(function () {
        return _this7.scrollToOption(_this7.selected);
      });
    },
    emitChange: function emitChange(val) {
      if (!Object(util_["valueEquals"])(this.value, val)) {
        this.$emit('change', val);
      }
    },
    getOption: function getOption(value) {
      var option = void 0;
      var isObject = Object.prototype.toString.call(value).toLowerCase() === '[object object]';
      var isNull = Object.prototype.toString.call(value).toLowerCase() === '[object null]';
      var isUndefined = Object.prototype.toString.call(value).toLowerCase() === '[object undefined]';

      for (var i = this.cachedOptions.length - 1; i >= 0; i--) {
        var cachedOption = this.cachedOptions[i];
        var isEqual = isObject ? Object(util_["getValueByPath"])(cachedOption.value, this.valueKey) === Object(util_["getValueByPath"])(value, this.valueKey) : cachedOption.value === value;
        if (isEqual) {
          option = cachedOption;
          break;
        }
      }
      if (option) return option;
      var label = !isObject && !isNull && !isUndefined ? value : '';
      var newOption = {
        value: value,
        currentLabel: label
      };
      if (this.multiple) {
        newOption.hitState = false;
      }
      return newOption;
    },
    setSelected: function setSelected() {
      var _this8 = this;

      if (!this.multiple) {
        var option = this.getOption(this.value);
        if (option.created) {
          this.createdLabel = option.currentLabel;
          this.createdSelected = true;
        } else {
          this.createdSelected = false;
        }
        this.selectedLabel = option.currentLabel;
        this.selected = option;
        if (this.filterable) this.query = this.selectedLabel;
        return;
      }
      var result = [];
      if (Array.isArray(this.value)) {
        this.value.forEach(function (value) {
          result.push(_this8.getOption(value));
        });
      }
      this.selected = result;
      this.$nextTick(function () {
        _this8.resetInputHeight();
      });
    },
    handleFocus: function handleFocus(event) {
      if (!this.softFocus) {
        if (this.automaticDropdown || this.filterable) {
          this.visible = true;
          if (this.filterable) {
            this.menuVisibleOnFocus = true;
          }
        }
        this.$emit('focus', event);
      } else {
        this.softFocus = false;
      }
    },
    blur: function blur() {
      this.visible = false;
      this.$refs.reference.blur();
    },
    handleBlur: function handleBlur(event) {
      var _this9 = this;

      setTimeout(function () {
        if (_this9.isSilentBlur) {
          _this9.isSilentBlur = false;
        } else {
          _this9.$emit('blur', event);
        }
      }, 50);
      this.softFocus = false;
    },
    handleClearClick: function handleClearClick(event) {
      this.deleteSelected(event);
    },
    doDestroy: function doDestroy() {
      this.$refs.popper && this.$refs.popper.doDestroy();
    },
    handleClose: function handleClose() {
      this.visible = false;
    },
    toggleLastOptionHitState: function toggleLastOptionHitState(hit) {
      if (!Array.isArray(this.selected)) return;
      var option = this.selected[this.selected.length - 1];
      if (!option) return;

      if (hit === true || hit === false) {
        option.hitState = hit;
        return hit;
      }

      option.hitState = !option.hitState;
      return option.hitState;
    },
    deletePrevTag: function deletePrevTag(e) {
      if (e.target.value.length <= 0 && !this.toggleLastOptionHitState()) {
        var value = this.value.slice();
        value.pop();
        this.$emit('input', value);
        this.emitChange(value);
      }
    },
    managePlaceholder: function managePlaceholder() {
      if (this.currentPlaceholder !== '') {
        this.currentPlaceholder = this.$refs.input.value ? '' : this.cachedPlaceHolder;
      }
    },
    resetInputState: function resetInputState(e) {
      if (e.keyCode !== 8) this.toggleLastOptionHitState(false);
      this.inputLength = this.$refs.input.value.length * 15 + 20;
      this.resetInputHeight();
    },
    resetInputHeight: function resetInputHeight() {
      var _this10 = this;

      if (this.collapseTags && !this.filterable) return;
      this.$nextTick(function () {
        if (!_this10.$refs.reference) return;
        var inputChildNodes = _this10.$refs.reference.$el.childNodes;
        var input = [].filter.call(inputChildNodes, function (item) {
          return item.tagName === 'INPUT';
        })[0];
        var tags = _this10.$refs.tags;
        var sizeInMap = _this10.initialInputHeight || 40;
        input.style.height = _this10.selected.length === 0 ? sizeInMap + 'px' : Math.max(tags ? tags.clientHeight + (tags.clientHeight > sizeInMap ? 6 : 0) : 0, sizeInMap) + 'px';
        if (_this10.visible && _this10.emptyText !== false) {
          _this10.broadcast('ElSelectDropdown', 'updatePopper');
        }
      });
    },
    resetHoverIndex: function resetHoverIndex() {
      var _this11 = this;

      setTimeout(function () {
        if (!_this11.multiple) {
          _this11.hoverIndex = _this11.options.indexOf(_this11.selected);
        } else {
          if (_this11.selected.length > 0) {
            _this11.hoverIndex = Math.min.apply(null, _this11.selected.map(function (item) {
              return _this11.options.indexOf(item);
            }));
          } else {
            _this11.hoverIndex = -1;
          }
        }
      }, 300);
    },
    handleOptionSelect: function handleOptionSelect(option, byClick) {
      var _this12 = this;

      if (this.multiple) {
        var value = (this.value || []).slice();
        var optionIndex = this.getValueIndex(value, option.value);
        if (optionIndex > -1) {
          value.splice(optionIndex, 1);
        } else if (this.multipleLimit <= 0 || value.length < this.multipleLimit) {
          value.push(option.value);
        }
        this.$emit('input', value);
        this.emitChange(value);
        if (option.created) {
          this.query = '';
          this.handleQueryChange('');
          this.inputLength = 20;
        }
        if (this.filterable) this.$refs.input.focus();
      } else {
        this.$emit('input', option.value);
        this.emitChange(option.value);
        this.visible = false;
      }
      this.isSilentBlur = byClick;
      this.setSoftFocus();
      if (this.visible) return;
      this.$nextTick(function () {
        _this12.scrollToOption(option);
      });
    },
    setSoftFocus: function setSoftFocus() {
      this.softFocus = true;
      var input = this.$refs.input || this.$refs.reference;
      if (input) {
        input.focus();
      }
    },
    getValueIndex: function getValueIndex() {
      var arr = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
      var value = arguments[1];

      var isObject = Object.prototype.toString.call(value).toLowerCase() === '[object object]';
      if (!isObject) {
        return arr.indexOf(value);
      } else {
        var valueKey = this.valueKey;
        var index = -1;
        arr.some(function (item, i) {
          if (Object(util_["getValueByPath"])(item, valueKey) === Object(util_["getValueByPath"])(value, valueKey)) {
            index = i;
            return true;
          }
          return false;
        });
        return index;
      }
    },
    toggleMenu: function toggleMenu() {
      if (!this.selectDisabled) {
        if (this.menuVisibleOnFocus) {
          this.menuVisibleOnFocus = false;
        } else {
          this.visible = !this.visible;
        }
        if (this.visible) {
          (this.$refs.input || this.$refs.reference).focus();
        }
      }
    },
    selectOption: function selectOption() {
      if (!this.visible) {
        this.toggleMenu();
      } else {
        if (this.options[this.hoverIndex]) {
          this.handleOptionSelect(this.options[this.hoverIndex]);
        }
      }
    },
    deleteSelected: function deleteSelected(event) {
      event.stopPropagation();
      var value = this.multiple ? [] : '';
      this.$emit('input', value);
      this.emitChange(value);
      this.visible = false;
      this.$emit('clear');
    },
    deleteTag: function deleteTag(event, tag) {
      var index = this.selected.indexOf(tag);
      if (index > -1 && !this.selectDisabled) {
        var value = this.value.slice();
        value.splice(index, 1);
        this.$emit('input', value);
        this.emitChange(value);
        this.$emit('remove-tag', tag.value);
      }
      event.stopPropagation();
    },
    onInputChange: function onInputChange() {
      if (this.filterable && this.query !== this.selectedLabel) {
        this.query = this.selectedLabel;
        this.handleQueryChange(this.query);
      }
    },
    onOptionDestroy: function onOptionDestroy(index) {
      if (index > -1) {
        this.optionsCount--;
        this.filteredOptionsCount--;
        this.options.splice(index, 1);
      }
    },
    resetInputWidth: function resetInputWidth() {
      this.inputWidth = this.$refs.reference.$el.getBoundingClientRect().width;
    },
    handleResize: function handleResize() {
      this.resetInputWidth();
      if (this.multiple) this.resetInputHeight();
    },
    checkDefaultFirstOption: function checkDefaultFirstOption() {
      this.hoverIndex = -1;
      // highlight the created option
      var hasCreated = false;
      for (var i = this.options.length - 1; i >= 0; i--) {
        if (this.options[i].created) {
          hasCreated = true;
          this.hoverIndex = i;
          break;
        }
      }
      if (hasCreated) return;
      for (var _i = 0; _i !== this.options.length; ++_i) {
        var option = this.options[_i];
        if (this.query) {
          // highlight first options that passes the filter
          if (!option.disabled && !option.groupDisabled && option.visible) {
            this.hoverIndex = _i;
            break;
          }
        } else {
          // highlight currently selected option
          if (option.itemSelected) {
            this.hoverIndex = _i;
            break;
          }
        }
      }
    },
    getValueKey: function getValueKey(item) {
      if (Object.prototype.toString.call(item.value).toLowerCase() !== '[object object]') {
        return item.value;
      } else {
        return Object(util_["getValueByPath"])(item.value, this.valueKey);
      }
    }
  },

  created: function created() {
    var _this13 = this;

    this.cachedPlaceHolder = this.currentPlaceholder = this.propPlaceholder;
    if (this.multiple && !Array.isArray(this.value)) {
      this.$emit('input', []);
    }
    if (!this.multiple && Array.isArray(this.value)) {
      this.$emit('input', '');
    }

    this.debouncedOnInputChange = debounce_default()(this.debounce, function () {
      _this13.onInputChange();
    });

    this.debouncedQueryChange = debounce_default()(this.debounce, function (e) {
      _this13.handleQueryChange(e.target.value);
    });

    this.$on('handleOptionClick', this.handleOptionSelect);
    this.$on('setSelected', this.setSelected);
  },
  mounted: function mounted() {
    var _this14 = this;

    if (this.multiple && Array.isArray(this.value) && this.value.length > 0) {
      this.currentPlaceholder = '';
    }
    Object(resize_event_["addResizeListener"])(this.$el, this.handleResize);

    var reference = this.$refs.reference;
    if (reference && reference.$el) {
      var sizeMap = {
        medium: 36,
        small: 32,
        mini: 28
      };
      var input = reference.$el.querySelector('input');
      this.initialInputHeight = input.getBoundingClientRect().height || sizeMap[this.selectSize];
    }
    if (this.remote && this.multiple) {
      this.resetInputHeight();
    }
    this.$nextTick(function () {
      if (reference && reference.$el) {
        _this14.inputWidth = reference.$el.getBoundingClientRect().width;
      }
    });
    this.setSelected();
  },
  beforeDestroy: function beforeDestroy() {
    if (this.$el && this.handleResize) Object(resize_event_["removeResizeListener"])(this.$el, this.handleResize);
  }
});
// CONCATENATED MODULE: ./packages/select/src/select.vue?vue&type=script&lang=js&
 /* harmony default export */ var src_selectvue_type_script_lang_js_ = (selectvue_type_script_lang_js_); 
// CONCATENATED MODULE: ./packages/select/src/select.vue





/* normalize component */

var select_component = Object(componentNormalizer["a" /* default */])(
  src_selectvue_type_script_lang_js_,
  render,
  staticRenderFns,
  false,
  null,
  null,
  null
  
)

/* hot reload */
if (false) { var select_api; }
select_component.options.__file = "packages/select/src/select.vue"
/* harmony default export */ var src_select = __webpack_exports__["a"] = (select_component.exports);

/***/ }),
/* 44 */,
/* 45 */,
/* 46 */
/***/ (function(module, exports) {

module.exports = require("forever-zu/lib/tag");

/***/ }),
/* 47 */,
/* 48 */,
/* 49 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return toString; });
var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };

function toString(val) {
  return val == null ? '' : (typeof val === 'undefined' ? 'undefined' : _typeof(val)) === 'object' ? JSON.stringify(val, null, 2) : String(val);
}

/***/ }),
/* 50 */,
/* 51 */,
/* 52 */,
/* 53 */,
/* 54 */,
/* 55 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";
// ESM COMPAT FLAG
__webpack_require__.r(__webpack_exports__);

// CONCATENATED MODULE: ./packages/col/src/col.js
var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };

/* harmony default export */ var col = ({
  name: 'ElCol',

  props: {
    span: {
      type: Number,
      default: 24
    },
    tag: {
      type: String,
      default: 'div'
    },
    offset: Number,
    pull: Number,
    push: Number,
    xs: [Number, Object],
    sm: [Number, Object],
    md: [Number, Object],
    lg: [Number, Object],
    xl: [Number, Object]
  },

  computed: {
    gutter: function gutter() {
      var parent = this.$parent;
      while (parent && parent.$options.componentName !== 'ElRow') {
        parent = parent.$parent;
      }
      return parent ? parent.gutter : 0;
    }
  },
  render: function render(h) {
    var _this = this;

    var classList = [];
    var style = {};

    if (this.gutter) {
      style.paddingLeft = this.gutter / 2 + 'px';
      style.paddingRight = style.paddingLeft;
    }

    ['span', 'offset', 'pull', 'push'].forEach(function (prop) {
      if (_this[prop] || _this[prop] === 0) {
        classList.push(prop !== 'span' ? 'el-col-' + prop + '-' + _this[prop] : 'el-col-' + _this[prop]);
      }
    });

    ['xs', 'sm', 'md', 'lg', 'xl'].forEach(function (size) {
      if (typeof _this[size] === 'number') {
        classList.push('el-col-' + size + '-' + _this[size]);
      } else if (_typeof(_this[size]) === 'object') {
        var props = _this[size];
        Object.keys(props).forEach(function (prop) {
          classList.push(prop !== 'span' ? 'el-col-' + size + '-' + prop + '-' + props[prop] : 'el-col-' + size + '-' + props[prop]);
        });
      }
    });

    return h(this.tag, {
      class: ['el-col', classList],
      style: style
    }, this.$slots.default);
  }
});
// CONCATENATED MODULE: ./packages/col/index.js


/* istanbul ignore next */
col.install = function (Vue) {
  Vue.component(col.name, col);
};

/* harmony default export */ var packages_col = __webpack_exports__["default"] = (col);

/***/ }),
/* 56 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";
// ESM COMPAT FLAG
__webpack_require__.r(__webpack_exports__);

// CONCATENATED MODULE: ./node_modules/vue-loader/lib/loaders/templateLoader.js??vue-loader-options!./node_modules/vue-loader/lib??vue-loader-options!./packages/upload/src/upload-list.vue?vue&type=template&id=173fedf5&
var upload_listvue_type_template_id_173fedf5_render = function() {
  var _vm = this
  var _h = _vm.$createElement
  var _c = _vm._self._c || _h
  return _c(
    "transition-group",
    {
      class: [
        "el-upload-list",
        "el-upload-list--" + _vm.listType,
        { "is-disabled": _vm.disabled }
      ],
      attrs: { tag: "ul", name: "el-list" }
    },
    _vm._l(_vm.files, function(file) {
      return _c(
        "li",
        {
          key: file.uid,
          class: [
            "el-upload-list__item",
            "is-" + file.status,
            _vm.focusing ? "focusing" : ""
          ],
          style: _vm.uploadListStyle,
          attrs: { tabindex: "0" },
          on: {
            keydown: function($event) {
              if (
                !("button" in $event) &&
                _vm._k($event.keyCode, "delete", [8, 46], $event.key, [
                  "Backspace",
                  "Delete",
                  "Del"
                ])
              ) {
                return null
              }
              !_vm.disabled && _vm.$emit("remove", file)
            },
            focus: function($event) {
              _vm.focusing = true
            },
            blur: function($event) {
              _vm.focusing = false
            },
            click: function($event) {
              _vm.focusing = false
            }
          }
        },
        [
          _vm._t(
            "default",
            [
              file.status !== "uploading" &&
              ["picture-card", "picture"].indexOf(_vm.listType) > -1
                ? _c("img", {
                    staticClass: "el-upload-list__item-thumbnail",
                    attrs: { src: file.url, alt: "" }
                  })
                : _vm._e(),
              _c(
                "a",
                {
                  staticClass: "el-upload-list__item-name",
                  on: {
                    click: function($event) {
                      _vm.handleClick(file)
                    }
                  }
                },
                [
                  _c("i", { staticClass: "el-icon-document" }),
                  _vm._v(_vm._s(file.name) + "\n      ")
                ]
              ),
              _c(
                "label",
                { staticClass: "el-upload-list__item-status-label" },
                [
                  _c("i", {
                    class: {
                      "el-icon-upload-success": true,
                      "el-icon-circle-check": _vm.listType === "text",
                      "el-icon-check":
                        ["picture-card", "picture"].indexOf(_vm.listType) > -1
                    }
                  })
                ]
              ),
              !_vm.disabled
                ? _c("i", {
                    staticClass: "el-icon-close",
                    on: {
                      click: function($event) {
                        _vm.$emit("remove", file)
                      }
                    }
                  })
                : _vm._e(),
              !_vm.disabled
                ? _c("i", { staticClass: "el-icon-close-tip" }, [
                    _vm._v(_vm._s(_vm.t("el.upload.deleteTip")))
                  ])
                : _vm._e(),
              file.status === "uploading"
                ? _c("el-progress", {
                    attrs: {
                      type: _vm.listType === "picture-card" ? "circle" : "line",
                      "stroke-width": _vm.listType === "picture-card" ? 6 : 2,
                      percentage: _vm.parsePercentage(file.percentage)
                    }
                  })
                : _vm._e(),
              _vm.listType === "picture-card"
                ? _c("span", { staticClass: "el-upload-list__item-actions" }, [
                    _vm.handlePreview && _vm.listType === "picture-card"
                      ? _c(
                          "span",
                          {
                            staticClass: "el-upload-list__item-preview",
                            on: {
                              click: function($event) {
                                _vm.handlePreview(file)
                              }
                            }
                          },
                          [_c("i", { staticClass: "el-icon-zoom-in" })]
                        )
                      : _vm._e(),
                    !_vm.disabled
                      ? _c(
                          "span",
                          {
                            staticClass: "el-upload-list__item-delete",
                            on: {
                              click: function($event) {
                                _vm.$emit("remove", file)
                              }
                            }
                          },
                          [_c("i", { staticClass: "el-icon-delete" })]
                        )
                      : _vm._e()
                  ])
                : _vm._e()
            ],
            { file: file }
          )
        ],
        2
      )
    }),
    0
  )
}
var staticRenderFns = []
upload_listvue_type_template_id_173fedf5_render._withStripped = true


// CONCATENATED MODULE: ./packages/upload/src/upload-list.vue?vue&type=template&id=173fedf5&

// EXTERNAL MODULE: external "forever-zu/lib/mixins/locale"
var locale_ = __webpack_require__(8);
var locale_default = /*#__PURE__*/__webpack_require__.n(locale_);

// EXTERNAL MODULE: external "forever-zu/lib/progress"
var progress_ = __webpack_require__(40);
var progress_default = /*#__PURE__*/__webpack_require__.n(progress_);

// CONCATENATED MODULE: ./node_modules/babel-loader/lib!./node_modules/vue-loader/lib??vue-loader-options!./packages/upload/src/upload-list.vue?vue&type=script&lang=js&
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//




/* harmony default export */ var upload_listvue_type_script_lang_js_ = ({

  name: 'ElUploadList',

  mixins: [locale_default.a],

  data: function data() {
    return {
      focusing: false
    };
  },

  computed: {
    uploadListStyle: function uploadListStyle() {
      var styleObj = {};
      for (var key in this.styleObj) {
        if (Object.hasOwnProperty.call(this.styleObj, key)) {
          var element = this.styleObj[key];
          styleObj[key] = element;
        }
      }
      return styleObj;
    }
  },
  components: { ElProgress: progress_default.a },
  mounted: function mounted() {},

  props: {
    files: {
      type: Array,
      default: function _default() {
        return [];
      }
    },
    styleObj: {
      type: Object,
      default: function _default() {
        return {};
      }
    },
    disabled: {
      type: Boolean,
      default: false
    },
    handlePreview: Function,
    listType: String,
    listShowLabel: {
      type: String,
      default: 'name'
    }
  },
  methods: {
    parsePercentage: function parsePercentage(val) {
      return parseInt(val, 10);
    },
    handleClick: function handleClick(file) {
      console.log(file);
      this.handlePreview && this.handlePreview(file);
    }
  }
});
// CONCATENATED MODULE: ./packages/upload/src/upload-list.vue?vue&type=script&lang=js&
 /* harmony default export */ var src_upload_listvue_type_script_lang_js_ = (upload_listvue_type_script_lang_js_); 
// EXTERNAL MODULE: ./node_modules/vue-loader/lib/runtime/componentNormalizer.js
var componentNormalizer = __webpack_require__(0);

// CONCATENATED MODULE: ./packages/upload/src/upload-list.vue





/* normalize component */

var component = Object(componentNormalizer["a" /* default */])(
  src_upload_listvue_type_script_lang_js_,
  upload_listvue_type_template_id_173fedf5_render,
  staticRenderFns,
  false,
  null,
  null,
  null
  
)

/* hot reload */
if (false) { var api; }
component.options.__file = "packages/upload/src/upload-list.vue"
/* harmony default export */ var upload_list = (component.exports);
// EXTERNAL MODULE: external "babel-helper-vue-jsx-merge-props"
var external_babel_helper_vue_jsx_merge_props_ = __webpack_require__(22);
var external_babel_helper_vue_jsx_merge_props_default = /*#__PURE__*/__webpack_require__.n(external_babel_helper_vue_jsx_merge_props_);

// CONCATENATED MODULE: ./packages/upload/src/ajax.js
function getError(action, option, xhr) {
  var msg = void 0;
  if (xhr.response) {
    msg = '' + (xhr.response.error || xhr.response);
  } else if (xhr.responseText) {
    msg = '' + xhr.responseText;
  } else {
    msg = 'fail to post ' + action + ' ' + xhr.status;
  }

  var err = new Error(msg);
  err.status = xhr.status;
  err.method = 'post';
  err.url = action;
  return err;
}

function getBody(xhr) {
  var text = xhr.responseText || xhr.response;
  if (!text) {
    return text;
  }

  try {
    return JSON.parse(text);
  } catch (e) {
    return text;
  }
}

function upload(option) {
  if (typeof XMLHttpRequest === 'undefined') {
    return;
  }

  var xhr = new XMLHttpRequest();
  var action = option.action;

  if (xhr.upload) {
    xhr.upload.onprogress = function progress(e) {
      if (e.total > 0) {
        e.percent = e.loaded / e.total * 100;
      }
      option.onProgress(e);
    };
  }

  var formData = new FormData();

  if (option.data) {
    Object.keys(option.data).forEach(function (key) {
      formData.append(key, option.data[key]);
    });
  }

  formData.append(option.filename, option.file, option.file.name);

  xhr.onerror = function error(e) {
    option.onError(e);
  };

  xhr.onload = function onload() {
    if (xhr.status < 200 || xhr.status >= 300) {
      return option.onError(getError(action, option, xhr));
    }

    option.onSuccess(getBody(xhr));
  };

  xhr.open('post', action, true);

  if (option.withCredentials && 'withCredentials' in xhr) {
    xhr.withCredentials = true;
  }

  var headers = option.headers || {};

  for (var item in headers) {
    if (headers.hasOwnProperty(item) && headers[item] !== null) {
      xhr.setRequestHeader(item, headers[item]);
    }
  }
  xhr.send(formData);
  return xhr;
}
// CONCATENATED MODULE: ./node_modules/vue-loader/lib/loaders/templateLoader.js??vue-loader-options!./node_modules/vue-loader/lib??vue-loader-options!./packages/upload/src/upload-dragger.vue?vue&type=template&id=7ebbf219&
var upload_draggervue_type_template_id_7ebbf219_render = function() {
  var _vm = this
  var _h = _vm.$createElement
  var _c = _vm._self._c || _h
  return _c(
    "div",
    {
      staticClass: "el-upload-dragger",
      class: {
        "is-dragover": _vm.dragover
      },
      on: {
        drop: function($event) {
          $event.preventDefault()
          return _vm.onDrop($event)
        },
        dragover: function($event) {
          $event.preventDefault()
          return _vm.onDragover($event)
        },
        dragleave: function($event) {
          $event.preventDefault()
          _vm.dragover = false
        }
      }
    },
    [_vm._t("default")],
    2
  )
}
var upload_draggervue_type_template_id_7ebbf219_staticRenderFns = []
upload_draggervue_type_template_id_7ebbf219_render._withStripped = true


// CONCATENATED MODULE: ./packages/upload/src/upload-dragger.vue?vue&type=template&id=7ebbf219&

// CONCATENATED MODULE: ./node_modules/babel-loader/lib!./node_modules/vue-loader/lib??vue-loader-options!./packages/upload/src/upload-dragger.vue?vue&type=script&lang=js&
//
//
//
//
//
//
//
//
//
//
//
//
//

/* harmony default export */ var upload_draggervue_type_script_lang_js_ = ({
  name: 'ElUploadDrag',
  props: {
    disabled: Boolean
  },
  inject: {
    uploader: {
      default: ''
    }
  },
  data: function data() {
    return {
      dragover: false
    };
  },
  mounted: function mounted() {},

  methods: {
    onDragover: function onDragover() {
      if (!this.disabled) {
        this.dragover = true;
      }
    },
    onDrop: function onDrop(e) {
      if (this.disabled || !this.uploader) return;
      var accept = this.uploader.accept;
      this.dragover = false;
      if (!accept) {
        this.$emit('file', e.dataTransfer.files);
        return;
      }
      this.$emit('file', [].slice.call(e.dataTransfer.files).filter(function (file) {
        var type = file.type,
            name = file.name;

        var extension = name.indexOf('.') > -1 ? '.' + name.split('.').pop() : '';
        var baseType = type.replace(/\/.*$/, '');
        return accept.split(',').map(function (type) {
          return type.trim();
        }).filter(function (type) {
          return type;
        }).some(function (acceptedType) {
          if (/\..+$/.test(acceptedType)) {
            return extension === acceptedType;
          }
          if (/\/\*$/.test(acceptedType)) {
            return baseType === acceptedType.replace(/\/\*$/, '');
          }
          if (/^[^\/]+\/[^\/]+$/.test(acceptedType)) {
            return type === acceptedType;
          }
          return false;
        });
      }));
    }
  }
});
// CONCATENATED MODULE: ./packages/upload/src/upload-dragger.vue?vue&type=script&lang=js&
 /* harmony default export */ var src_upload_draggervue_type_script_lang_js_ = (upload_draggervue_type_script_lang_js_); 
// CONCATENATED MODULE: ./packages/upload/src/upload-dragger.vue





/* normalize component */

var upload_dragger_component = Object(componentNormalizer["a" /* default */])(
  src_upload_draggervue_type_script_lang_js_,
  upload_draggervue_type_template_id_7ebbf219_render,
  upload_draggervue_type_template_id_7ebbf219_staticRenderFns,
  false,
  null,
  null,
  null
  
)

/* hot reload */
if (false) { var upload_dragger_api; }
upload_dragger_component.options.__file = "packages/upload/src/upload-dragger.vue"
/* harmony default export */ var upload_dragger = (upload_dragger_component.exports);
// CONCATENATED MODULE: ./node_modules/babel-loader/lib!./node_modules/vue-loader/lib??vue-loader-options!./packages/upload/src/upload.vue?vue&type=script&lang=js&


var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };




/* harmony default export */ var uploadvue_type_script_lang_js_ = ({
  inject: ['uploader'],
  components: {
    UploadDragger: upload_dragger
  },
  props: {
    styleObj: {},
    type: String,
    action: {
      type: String,
      required: true
    },
    name: {
      type: String,
      default: 'file'
    },
    data: Object,
    headers: Object,
    withCredentials: Boolean,
    multiple: Boolean,
    accept: String,
    onStart: Function,
    onProgress: Function,
    onSuccess: Function,
    onError: Function,
    beforeUpload: Function,
    drag: Boolean,
    onPreview: {
      type: Function,
      default: function _default() {}
    },
    onRemove: {
      type: Function,
      default: function _default() {}
    },
    fileList: Array,
    autoUpload: Boolean,
    listType: String,
    httpRequest: {
      type: Function,
      default: upload
    },
    disabled: Boolean,
    limit: Number,
    onExceed: Function

  },

  data: function data() {
    return {
      mouseover: false,
      reqs: {}
    };
  },


  methods: {
    isImage: function isImage(str) {
      return str.indexOf('image') !== -1;
    },
    handleChange: function handleChange(ev) {
      var files = ev.target.files;
      if (!files) return;
      this.uploadFiles(files);
    },
    uploadFiles: function uploadFiles(files) {
      var _this = this;

      if (this.limit && this.fileList.length + files.length > this.limit) {
        this.onExceed && this.onExceed(files, this.fileList);
        return;
      }

      var postFiles = Array.prototype.slice.call(files);
      if (!this.multiple) {
        postFiles = postFiles.slice(0, 1);
      }

      if (postFiles.length === 0) {
        return;
      }

      postFiles.forEach(function (rawFile) {
        _this.onStart(rawFile);
        if (_this.autoUpload) _this.upload(rawFile);
      });
    },
    upload: function upload(rawFile) {
      var _this2 = this;

      this.$refs.input.value = null;
      if (!this.beforeUpload) {
        return this.post(rawFile);
      }
      var before = this.beforeUpload(rawFile);
      if (before && before.then) {
        before.then(function (processedFile) {
          var fileType = Object.prototype.toString.call(processedFile);
          if (fileType === '[object File]' || fileType === '[object Blob]') {
            if (fileType === '[object Blob]') {
              processedFile = new File([processedFile], rawFile.name, {
                type: rawFile.type
              });
            }
            for (var p in rawFile) {
              if (rawFile.hasOwnProperty(p)) {
                processedFile[p] = rawFile[p];
              }
            }
            _this2.post(processedFile);
          } else {
            _this2.post(rawFile);
          }
        }, function () {
          _this2.onRemove(null, rawFile);
        });
      } else if (before !== false) {
        this.post(rawFile);
      } else {
        this.onRemove(null, rawFile);
      }
    },
    abort: function abort(file) {
      var reqs = this.reqs;

      if (file) {
        var uid = file;
        if (file.uid) uid = file.uid;
        if (reqs[uid]) {
          reqs[uid].abort();
        }
      } else {
        Object.keys(reqs).forEach(function (uid) {
          if (reqs[uid]) reqs[uid].abort();
          delete reqs[uid];
        });
      }
    },
    post: function post(rawFile) {
      var _this3 = this;

      var uid = rawFile.uid;

      var options = {
        headers: this.headers,
        withCredentials: this.withCredentials,
        file: rawFile,
        data: this.data,
        filename: this.name,
        action: this.action,
        onProgress: function onProgress(e) {
          _this3.onProgress(e, rawFile);
        },
        onSuccess: function onSuccess(res) {
          _this3.onSuccess(res, rawFile);
          delete _this3.reqs[uid];
        },
        onError: function onError(err) {
          _this3.onError(err, rawFile);
          delete _this3.reqs[uid];
        }
      };
      var req = this.httpRequest(options);
      this.reqs[uid] = req;
      if (req && req.then) {
        req.then(options.onSuccess, options.onError);
      }
    },
    handleClick: function handleClick() {
      if (!this.disabled) {
        this.$refs.input.value = null;
        this.$refs.input.click();
      }
    },
    handleKeydown: function handleKeydown(e) {
      if (e.target !== e.currentTarget) return;
      if (e.keyCode === 13 || e.keyCode === 32) {
        this.handleClick();
      }
    }
  },

  render: function render(h) {
    var handleClick = this.handleClick,
        drag = this.drag,
        name = this.name,
        handleChange = this.handleChange,
        multiple = this.multiple,
        accept = this.accept,
        listType = this.listType,
        uploadFiles = this.uploadFiles,
        disabled = this.disabled,
        handleKeydown = this.handleKeydown;

    var data = {
      class: {
        'el-upload': true
      },
      on: {
        click: handleClick,
        keydown: handleKeydown
      },
      style: _extends({}, this.styleObj)
    };
    data.class['el-upload--' + listType] = true;
    return h(
      'div',
      external_babel_helper_vue_jsx_merge_props_default()([data, {
        attrs: { tabindex: '0' }
      }]),
      [drag ? h(
        'upload-dragger',
        {
          attrs: { disabled: disabled },
          on: {
            'file': uploadFiles
          }
        },
        [this.$slots.default]
      ) : this.$slots.default, h('input', { 'class': 'el-upload__input', attrs: { type: 'file', name: name, multiple: multiple, accept: accept },
        ref: 'input', on: {
          'change': handleChange
        }
      })]
    );
  }
});
// CONCATENATED MODULE: ./packages/upload/src/upload.vue?vue&type=script&lang=js&
 /* harmony default export */ var src_uploadvue_type_script_lang_js_ = (uploadvue_type_script_lang_js_); 
// CONCATENATED MODULE: ./packages/upload/src/upload.vue
var upload_render, upload_staticRenderFns




/* normalize component */

var upload_component = Object(componentNormalizer["a" /* default */])(
  src_uploadvue_type_script_lang_js_,
  upload_render,
  upload_staticRenderFns,
  false,
  null,
  null,
  null
  
)

/* hot reload */
if (false) { var upload_api; }
upload_component.options.__file = "packages/upload/src/upload.vue"
/* harmony default export */ var src_upload = (upload_component.exports);
// EXTERNAL MODULE: external "forever-zu/lib/mixins/migrating"
var migrating_ = __webpack_require__(14);
var migrating_default = /*#__PURE__*/__webpack_require__.n(migrating_);

// CONCATENATED MODULE: ./node_modules/babel-loader/lib!./node_modules/vue-loader/lib??vue-loader-options!./packages/upload/src/index.vue?vue&type=script&lang=js&






function noop() {}

/* harmony default export */ var srcvue_type_script_lang_js_ = ({
  name: 'ElUpload',
  mixins: [migrating_default.a],

  components: {
    ElProgress: progress_default.a,
    UploadList: upload_list,
    Upload: src_upload
  },

  provide: function provide() {
    return {
      uploader: this
    };
  },


  inject: {
    elForm: {
      default: ''
    }
  },

  props: {
    // 简单调整一下upload的样式
    styleObj: {
      type: Object,
      default: function _default() {
        return {};
      }
    },
    // 新增的v-model
    value: {
      type: [String, Array],
      default: ''
    },
    // 新增的listShowLabel 用来展示不是name字段的file-list
    listShowLabel: {
      type: String,
      default: 'name'
    },
    action: {
      type: String,
      required: true
    },
    headers: {
      type: Object,
      default: function _default() {
        return {};
      }
    },
    data: Object,
    multiple: Boolean,
    name: {
      type: String,
      default: 'file'
    },
    drag: Boolean,
    dragger: Boolean,
    withCredentials: Boolean,
    showFileList: {
      type: Boolean,
      default: true
    },
    accept: String,
    type: {
      type: String,
      default: 'select'
    },
    beforeUpload: Function,
    beforeRemove: Function,
    onRemove: {
      type: Function,
      default: noop
    },

    onPreview: {
      type: Function
    },
    onSuccess: {
      type: Function,
      default: noop
    },
    onProgress: {
      type: Function,
      default: noop
    },
    onError: {
      type: Function,
      default: noop
    },
    fileList: {
      type: Array,
      default: function _default() {
        return [];
      }
    },
    autoUpload: {
      type: Boolean,
      default: true
    },
    listType: {
      type: String,
      default: 'text' // text,picture,picture-card
    },
    httpRequest: Function,
    disabled: Boolean,
    limit: Number,
    onExceed: {
      type: Function,
      default: noop
    }
  },

  data: function data() {
    return {
      uploadFiles: [],
      dragOver: false,
      draging: false,
      tempIndex: 1
    };
  },


  computed: {
    uploadDisabled: function uploadDisabled() {
      return this.disabled || (this.elForm || {}).disabled;
    }
  },

  watch: {
    listType: function listType(type) {
      if (type === 'picture-card' || type === 'picture') {
        this.uploadFiles = this.uploadFiles.map(function (file) {
          if (!file.url && file.raw) {
            try {
              file.url = URL.createObjectURL(file.raw);
            } catch (err) {
              console.error('[Element Error][Upload]', err);
            }
          }
          return file;
        });
      }
    },

    fileList: {
      immediate: true,
      handler: function handler(fileList) {
        var _this = this;

        this.uploadFiles = fileList.map(function (item) {
          item.uid = item.uid || Date.now() + _this.tempIndex++;
          item.status = item.status || 'success';
          if (!item.name) {
            item.name = item[_this.listShowLabel];
          }

          return item;
        });
      }
    }
  },

  methods: {
    handleStart: function handleStart(rawFile) {
      rawFile.uid = Date.now() + this.tempIndex++;
      var file = {
        status: 'ready',
        name: rawFile.name,
        size: rawFile.size,
        percentage: 0,
        uid: rawFile.uid,
        raw: rawFile
      };

      if (this.listType === 'picture-card' || this.listType === 'picture') {
        try {
          file.url = URL.createObjectURL(rawFile);
        } catch (err) {
          console.error('[Element Error][Upload]', err);
          return;
        }
      }

      this.uploadFiles.push(file);
      this.onChange(file, this.uploadFiles);
    },
    handleProgress: function handleProgress(ev, rawFile) {
      var file = this.getFile(rawFile);
      this.onProgress(ev, file, this.uploadFiles);
      file.status = 'uploading';
      file.percentage = ev.percent || 0;
    },

    // 当上传文件改变的时候
    onChange: function onChange(file, uploadFiles) {
      this.$emit('onChange', file, uploadFiles);
      this.$emit('input', uploadFiles);
    },

    // 上传成的func
    handleSuccess: function handleSuccess(res, rawFile) {
      var file = this.getFile(rawFile);
      if (file) {
        file.status = 'success';
        file.response = res;

        this.onSuccess(res, file, this.uploadFiles);
        this.onChange(file, this.uploadFiles);
      }
    },
    handleError: function handleError(err, rawFile) {
      var file = this.getFile(rawFile);
      var fileList = this.uploadFiles;

      file.status = 'fail';

      fileList.splice(fileList.indexOf(file), 1);

      this.onError(err, file, this.uploadFiles);
      this.onChange(file, this.uploadFiles);
    },
    handleRemove: function handleRemove(file, raw) {
      var _this2 = this;

      if (raw) {
        file = this.getFile(raw);
      }
      var doRemove = function doRemove() {
        _this2.abort(file);
        var fileList = _this2.uploadFiles;
        fileList.splice(fileList.indexOf(file), 1);
        _this2.onRemove(file, fileList);
      };

      if (!this.beforeRemove) {
        doRemove();
      } else if (typeof this.beforeRemove === 'function') {
        var before = this.beforeRemove(file, this.uploadFiles);
        if (before && before.then) {
          before.then(function () {
            doRemove();
          }, noop);
        } else if (before !== false) {
          doRemove();
        }
      }
    },
    getFile: function getFile(rawFile) {
      var fileList = this.uploadFiles;
      var target = void 0;
      fileList.every(function (item) {
        target = rawFile.uid === item.uid ? item : null;
        return !target;
      });
      return target;
    },
    abort: function abort(file) {
      this.$refs['upload-inner'].abort(file);
    },
    clearFiles: function clearFiles() {
      this.uploadFiles = [];
    },
    submit: function submit() {
      var _this3 = this;

      this.uploadFiles.filter(function (file) {
        return file.status === 'ready';
      }).forEach(function (file) {
        _this3.$refs['upload-inner'].upload(file.raw);
      });
    },
    getMigratingConfig: function getMigratingConfig() {
      return {
        props: {
          'default-file-list': 'default-file-list is renamed to file-list.',
          'show-upload-list': 'show-upload-list is renamed to show-file-list.',
          'thumbnail-mode': 'thumbnail-mode has been deprecated, you can implement the same effect according to this case: http://element.eleme.io/#/zh-CN/component/upload#yong-hu-tou-xiang-shang-chuan'
        }
      };
    }
  },

  beforeDestroy: function beforeDestroy() {
    this.uploadFiles.forEach(function (file) {
      if (file.url && file.url.indexOf('blob:') === 0) {
        URL.revokeObjectURL(file.url);
      }
    });
  },
  render: function render(h) {
    var _this4 = this;

    var uploadList = void 0;

    if (this.showFileList) {
      uploadList = h(
        upload_list,
        {
          attrs: {
            disabled: this.uploadDisabled,
            listType: this.listType,
            files: this.uploadFiles,

            styleObj: this.styleObj,
            handlePreview: this.onPreview },
          on: {
            'remove': this.handleRemove
          }
        },
        [function (props) {
          if (_this4.$scopedSlots.file) {
            return _this4.$scopedSlots.file({
              file: props.file
            });
          }
        }]
      );
    }
    var uploadData = {
      props: {
        type: this.type,
        drag: this.drag,
        action: this.action,
        multiple: this.multiple,
        'before-upload': this.beforeUpload,
        'with-credentials': this.withCredentials,
        headers: this.headers,
        name: this.name,
        data: this.data,
        accept: this.accept,
        fileList: this.uploadFiles,
        autoUpload: this.autoUpload,
        listType: this.listType,
        disabled: this.uploadDisabled,
        limit: this.limit,
        styleObj: this.styleObj,
        'on-exceed': this.onExceed,
        'on-start': this.handleStart,
        'on-progress': this.handleProgress,
        'on-success': this.handleSuccess,
        'on-error': this.handleError,
        'on-preview': this.onPreview,
        'on-remove': this.handleRemove,
        'http-request': this.httpRequest
      },
      ref: 'upload-inner'
    };

    var trigger = this.$slots.trigger || this.$slots.default;
    var uploadComponent = h(
      'upload',
      uploadData,
      [trigger]
    );
    return h('div', [this.listType === 'picture-card' ? uploadList : '', this.$slots.trigger ? [uploadComponent, this.$slots.default] : uploadComponent, this.$slots.tip, this.listType !== 'picture-card' ? uploadList : '']);
  }
});
// CONCATENATED MODULE: ./packages/upload/src/index.vue?vue&type=script&lang=js&
 /* harmony default export */ var upload_srcvue_type_script_lang_js_ = (srcvue_type_script_lang_js_); 
// CONCATENATED MODULE: ./packages/upload/src/index.vue
var src_render, src_staticRenderFns




/* normalize component */

var src_component = Object(componentNormalizer["a" /* default */])(
  upload_srcvue_type_script_lang_js_,
  src_render,
  src_staticRenderFns,
  false,
  null,
  null,
  null
  
)

/* hot reload */
if (false) { var src_api; }
src_component.options.__file = "packages/upload/src/index.vue"
/* harmony default export */ var src = (src_component.exports);
// CONCATENATED MODULE: ./packages/upload/index.js


/* istanbul ignore next */
src.install = function (Vue) {
  Vue.component(src.name, src);
};

/* harmony default export */ var packages_upload = __webpack_exports__["default"] = (src);

/***/ }),
/* 57 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";
// ESM COMPAT FLAG
__webpack_require__.r(__webpack_exports__);

// CONCATENATED MODULE: ./node_modules/vue-loader/lib/loaders/templateLoader.js??vue-loader-options!./node_modules/vue-loader/lib??vue-loader-options!./packages/tree/src/tree.vue?vue&type=template&id=547575a6&
var render = function() {
  var _vm = this
  var _h = _vm.$createElement
  var _c = _vm._self._c || _h
  return _c(
    "div",
    {
      staticClass: "el-tree",
      class: {
        "el-tree--highlight-current": _vm.highlightCurrent,
        "is-dragging": !!_vm.dragState.draggingNode,
        "is-drop-not-allow": !_vm.dragState.allowDrop,
        "is-drop-inner": _vm.dragState.dropType === "inner"
      },
      attrs: { role: "tree" }
    },
    [
      _vm._l(_vm.root.childNodes, function(child) {
        return _c("el-tree-node", {
          key: _vm.getNodeKey(child),
          attrs: {
            node: child,
            props: _vm.props,
            "render-after-expand": _vm.renderAfterExpand,
            "show-checkbox": _vm.showCheckbox,
            "render-content": _vm.renderContent
          },
          on: { "node-expand": _vm.handleNodeExpand }
        })
      }),
      _vm.isEmpty
        ? _c("div", { staticClass: "el-tree__empty-block" }, [
            _c("span", { staticClass: "el-tree__empty-text" }, [
              _vm._v(_vm._s(_vm.emptyText))
            ])
          ])
        : _vm._e(),
      _c("div", {
        directives: [
          {
            name: "show",
            rawName: "v-show",
            value: _vm.dragState.showDropIndicator,
            expression: "dragState.showDropIndicator"
          }
        ],
        ref: "dropIndicator",
        staticClass: "el-tree__drop-indicator"
      })
    ],
    2
  )
}
var staticRenderFns = []
render._withStripped = true


// CONCATENATED MODULE: ./packages/tree/src/tree.vue?vue&type=template&id=547575a6&

// EXTERNAL MODULE: external "forever-zu/lib/utils/merge"
var merge_ = __webpack_require__(12);
var merge_default = /*#__PURE__*/__webpack_require__.n(merge_);

// CONCATENATED MODULE: ./packages/tree/src/model/util.js
var NODE_KEY = '$treeNodeId';

var markNodeData = function markNodeData(node, data) {
  if (!data || data[NODE_KEY]) return;
  Object.defineProperty(data, NODE_KEY, {
    value: node.id,
    enumerable: false,
    configurable: false,
    writable: false
  });
};

var util_getNodeKey = function getNodeKey(key, data) {
  if (!key) return data[NODE_KEY];
  return data[key];
};

var findNearestComponent = function findNearestComponent(element, componentName) {
  var target = element;
  while (target && target.tagName !== 'BODY') {
    if (target.__vue__ && target.__vue__.$options.name === componentName) {
      return target.__vue__;
    }
    target = target.parentNode;
  }
  return null;
};
// EXTERNAL MODULE: external "forever-zu/lib/utils/util"
var util_ = __webpack_require__(3);

// CONCATENATED MODULE: ./packages/tree/src/model/node.js
var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }





var getChildState = function getChildState(node) {
  var all = true;
  var none = true;
  var allWithoutDisable = true;
  for (var i = 0, j = node.length; i < j; i++) {
    var n = node[i];
    if (n.checked !== true || n.indeterminate) {
      all = false;
      if (!n.disabled) {
        allWithoutDisable = false;
      }
    }
    if (n.checked !== false || n.indeterminate) {
      none = false;
    }
  }

  return { all: all, none: none, allWithoutDisable: allWithoutDisable, half: !all && !none };
};

var reInitChecked = function reInitChecked(node) {
  if (node.childNodes.length === 0) return;

  var _getChildState = getChildState(node.childNodes),
      all = _getChildState.all,
      none = _getChildState.none,
      half = _getChildState.half;

  if (all) {
    node.checked = true;
    node.indeterminate = false;
  } else if (half) {
    node.checked = false;
    node.indeterminate = true;
  } else if (none) {
    node.checked = false;
    node.indeterminate = false;
  }

  var parent = node.parent;
  if (!parent || parent.level === 0) return;

  if (!node.store.checkStrictly) {
    reInitChecked(parent);
  }
};

var getPropertyFromData = function getPropertyFromData(node, prop) {
  var props = node.store.props;
  var data = node.data || {};
  var config = props[prop];

  if (typeof config === 'function') {
    return config(data, node);
  } else if (typeof config === 'string') {
    return data[config];
  } else if (typeof config === 'undefined') {
    var dataProp = data[prop];
    return dataProp === undefined ? '' : dataProp;
  }
};

var nodeIdSeed = 0;

var node_Node = function () {
  function Node(options) {
    _classCallCheck(this, Node);

    this.id = nodeIdSeed++;
    this.text = null;
    this.checked = false;
    this.indeterminate = false;
    this.data = null;
    this.expanded = false;
    this.parent = null;
    this.visible = true;
    this.isCurrent = false;

    for (var name in options) {
      if (options.hasOwnProperty(name)) {
        this[name] = options[name];
      }
    }

    // internal
    this.level = 0;
    this.loaded = false;
    this.childNodes = [];
    this.loading = false;

    if (this.parent) {
      this.level = this.parent.level + 1;
    }

    var store = this.store;
    if (!store) {
      throw new Error('[Node]store is required!');
    }
    store.registerNode(this);

    var props = store.props;
    if (props && typeof props.isLeaf !== 'undefined') {
      var isLeaf = getPropertyFromData(this, 'isLeaf');
      if (typeof isLeaf === 'boolean') {
        this.isLeafByUser = isLeaf;
      }
    }

    if (store.lazy !== true && this.data) {
      this.setData(this.data);

      if (store.defaultExpandAll) {
        this.expanded = true;
      }
    } else if (this.level > 0 && store.lazy && store.defaultExpandAll) {
      this.expand();
    }
    if (!Array.isArray(this.data)) {
      markNodeData(this, this.data);
    }
    if (!this.data) return;
    var defaultExpandedKeys = store.defaultExpandedKeys;
    var key = store.key;
    if (key && defaultExpandedKeys && defaultExpandedKeys.indexOf(this.key) !== -1) {
      this.expand(null, store.autoExpandParent);
    }

    if (key && store.currentNodeKey !== undefined && this.key === store.currentNodeKey) {
      store.currentNode = this;
      store.currentNode.isCurrent = true;
    }

    if (store.lazy) {
      store._initDefaultCheckedNode(this);
    }

    this.updateLeafState();
  }

  Node.prototype.setData = function setData(data) {
    if (!Array.isArray(data)) {
      markNodeData(this, data);
    }

    this.data = data;
    this.childNodes = [];

    var children = void 0;
    if (this.level === 0 && this.data instanceof Array) {
      children = this.data;
    } else {
      children = getPropertyFromData(this, 'children') || [];
    }

    for (var i = 0, j = children.length; i < j; i++) {
      this.insertChild({ data: children[i] });
    }
  };

  Node.prototype.contains = function contains(target) {
    var deep = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;

    var walk = function walk(parent) {
      var children = parent.childNodes || [];
      var result = false;
      for (var i = 0, j = children.length; i < j; i++) {
        var child = children[i];
        if (child === target || deep && walk(child)) {
          result = true;
          break;
        }
      }
      return result;
    };

    return walk(this);
  };

  Node.prototype.remove = function remove() {
    var parent = this.parent;
    if (parent) {
      parent.removeChild(this);
    }
  };

  Node.prototype.insertChild = function insertChild(child, index, batch) {
    if (!child) throw new Error('insertChild error: child is required.');

    if (!(child instanceof Node)) {
      if (!batch) {
        var children = this.getChildren(true);
        if (children.indexOf(child.data) === -1) {
          if (typeof index === 'undefined' || index < 0) {
            children.push(child.data);
          } else {
            children.splice(index, 0, child.data);
          }
        }
      }
      merge_default()(child, {
        parent: this,
        store: this.store
      });
      child = new Node(child);
    }

    child.level = this.level + 1;

    if (typeof index === 'undefined' || index < 0) {
      this.childNodes.push(child);
    } else {
      this.childNodes.splice(index, 0, child);
    }

    this.updateLeafState();
  };

  Node.prototype.insertBefore = function insertBefore(child, ref) {
    var index = void 0;
    if (ref) {
      index = this.childNodes.indexOf(ref);
    }
    this.insertChild(child, index);
  };

  Node.prototype.insertAfter = function insertAfter(child, ref) {
    var index = void 0;
    if (ref) {
      index = this.childNodes.indexOf(ref);
      if (index !== -1) index += 1;
    }
    this.insertChild(child, index);
  };

  Node.prototype.removeChild = function removeChild(child) {
    var children = this.getChildren() || [];
    var dataIndex = children.indexOf(child.data);
    if (dataIndex > -1) {
      children.splice(dataIndex, 1);
    }

    var index = this.childNodes.indexOf(child);

    if (index > -1) {
      this.store && this.store.deregisterNode(child);
      child.parent = null;
      this.childNodes.splice(index, 1);
    }

    this.updateLeafState();
  };

  Node.prototype.removeChildByData = function removeChildByData(data) {
    var targetNode = null;

    for (var i = 0; i < this.childNodes.length; i++) {
      if (this.childNodes[i].data === data) {
        targetNode = this.childNodes[i];
        break;
      }
    }

    if (targetNode) {
      this.removeChild(targetNode);
    }
  };

  Node.prototype.expand = function expand(callback, expandParent) {
    var _this = this;

    var done = function done() {
      if (expandParent) {
        var parent = _this.parent;
        while (parent.level > 0) {
          parent.expanded = true;
          parent = parent.parent;
        }
      }
      _this.expanded = true;
      if (callback) callback();
    };

    if (this.shouldLoadData()) {
      this.loadData(function (data) {
        if (data instanceof Array) {
          if (_this.checked) {
            _this.setChecked(true, true);
          } else if (!_this.store.checkStrictly) {
            reInitChecked(_this);
          }
          done();
        }
      });
    } else {
      done();
    }
  };

  Node.prototype.doCreateChildren = function doCreateChildren(array) {
    var _this2 = this;

    var defaultProps = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};

    array.forEach(function (item) {
      _this2.insertChild(merge_default()({ data: item }, defaultProps), undefined, true);
    });
  };

  Node.prototype.collapse = function collapse() {
    this.expanded = false;
  };

  Node.prototype.shouldLoadData = function shouldLoadData() {
    return this.store.lazy === true && this.store.load && !this.loaded;
  };

  Node.prototype.updateLeafState = function updateLeafState() {
    if (this.store.lazy === true && this.loaded !== true && typeof this.isLeafByUser !== 'undefined') {
      this.isLeaf = this.isLeafByUser;
      return;
    }
    var childNodes = this.childNodes;
    if (!this.store.lazy || this.store.lazy === true && this.loaded === true) {
      this.isLeaf = !childNodes || childNodes.length === 0;
      return;
    }
    this.isLeaf = false;
  };

  Node.prototype.setChecked = function setChecked(value, deep, recursion, passValue) {
    var _this3 = this;

    this.indeterminate = value === 'half';
    this.checked = value === true;

    if (this.store.checkStrictly) return;

    if (!(this.shouldLoadData() && !this.store.checkDescendants)) {
      var _getChildState2 = getChildState(this.childNodes),
          all = _getChildState2.all,
          allWithoutDisable = _getChildState2.allWithoutDisable;

      if (!this.isLeaf && !all && allWithoutDisable) {
        this.checked = false;
        value = false;
      }

      var handleDescendants = function handleDescendants() {
        if (deep) {
          var childNodes = _this3.childNodes;
          for (var i = 0, j = childNodes.length; i < j; i++) {
            var child = childNodes[i];
            passValue = passValue || value !== false;
            var isCheck = child.disabled ? child.checked : passValue;
            child.setChecked(isCheck, deep, true, passValue);
          }

          var _getChildState3 = getChildState(childNodes),
              half = _getChildState3.half,
              _all = _getChildState3.all;

          if (!_all) {
            _this3.checked = _all;
            _this3.indeterminate = half;
          }
        }
      };

      if (this.shouldLoadData()) {
        // Only work on lazy load data.
        this.loadData(function () {
          handleDescendants();
          reInitChecked(_this3);
        }, {
          checked: value !== false
        });
        return;
      } else {
        handleDescendants();
      }
    }

    var parent = this.parent;
    if (!parent || parent.level === 0) return;

    if (!recursion) {
      reInitChecked(parent);
    }
  };

  Node.prototype.getChildren = function getChildren() {
    var forceInit = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
    // this is data
    if (this.level === 0) return this.data;
    var data = this.data;
    if (!data) return null;

    var props = this.store.props;
    var children = 'children';
    if (props) {
      children = props.children || 'children';
    }

    if (data[children] === undefined) {
      data[children] = null;
    }

    if (forceInit && !data[children]) {
      data[children] = [];
    }

    return data[children];
  };

  Node.prototype.updateChildren = function updateChildren() {
    var _this4 = this;

    var newData = this.getChildren() || [];
    var oldData = this.childNodes.map(function (node) {
      return node.data;
    });

    var newDataMap = {};
    var newNodes = [];

    newData.forEach(function (item, index) {
      var key = item[NODE_KEY];
      var isNodeExists = !!key && Object(util_["arrayFindIndex"])(oldData, function (data) {
        return data[NODE_KEY] === key;
      }) >= 0;
      if (isNodeExists) {
        newDataMap[key] = { index: index, data: item };
      } else {
        newNodes.push({ index: index, data: item });
      }
    });

    if (!this.store.lazy) {
      oldData.forEach(function (item) {
        if (!newDataMap[item[NODE_KEY]]) _this4.removeChildByData(item);
      });
    }

    newNodes.forEach(function (_ref) {
      var index = _ref.index,
          data = _ref.data;

      _this4.insertChild({ data: data }, index);
    });

    this.updateLeafState();
  };

  Node.prototype.loadData = function loadData(callback) {
    var _this5 = this;

    var defaultProps = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};

    if (this.store.lazy === true && this.store.load && !this.loaded && (!this.loading || Object.keys(defaultProps).length)) {
      this.loading = true;

      var resolve = function resolve(children) {
        _this5.loaded = true;
        _this5.loading = false;
        _this5.childNodes = [];

        _this5.doCreateChildren(children, defaultProps);

        _this5.updateLeafState();
        if (callback) {
          callback.call(_this5, children);
        }
      };

      this.store.load(this, resolve);
    } else {
      if (callback) {
        callback.call(this);
      }
    }
  };

  _createClass(Node, [{
    key: 'label',
    get: function get() {
      return getPropertyFromData(this, 'label');
    }
  }, {
    key: 'key',
    get: function get() {
      var nodeKey = this.store.key;
      if (this.data) return this.data[nodeKey];
      return null;
    }
  }, {
    key: 'disabled',
    get: function get() {
      return getPropertyFromData(this, 'disabled');
    }
  }, {
    key: 'nextSibling',
    get: function get() {
      var parent = this.parent;
      if (parent) {
        var index = parent.childNodes.indexOf(this);
        if (index > -1) {
          return parent.childNodes[index + 1];
        }
      }
      return null;
    }
  }, {
    key: 'previousSibling',
    get: function get() {
      var parent = this.parent;
      if (parent) {
        var index = parent.childNodes.indexOf(this);
        if (index > -1) {
          return index > 0 ? parent.childNodes[index - 1] : null;
        }
      }
      return null;
    }
  }]);

  return Node;
}();

/* harmony default export */ var model_node = (node_Node);
// CONCATENATED MODULE: ./packages/tree/src/model/tree-store.js
var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };

function tree_store_classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }




var tree_store_TreeStore = function () {
  function TreeStore(options) {
    var _this = this;

    tree_store_classCallCheck(this, TreeStore);

    this.currentNode = null;
    this.currentNodeKey = null;

    for (var option in options) {
      if (options.hasOwnProperty(option)) {
        this[option] = options[option];
      }
    }

    this.nodesMap = {};

    this.root = new model_node({
      data: this.data,
      store: this
    });

    if (this.lazy && this.load) {
      var loadFn = this.load;
      loadFn(this.root, function (data) {
        _this.root.doCreateChildren(data);
        _this._initDefaultCheckedNodes();
      });
    } else {
      this._initDefaultCheckedNodes();
    }
  }

  TreeStore.prototype.filter = function filter(value) {
    var filterNodeMethod = this.filterNodeMethod;
    var lazy = this.lazy;
    var traverse = function traverse(node) {
      var childNodes = node.root ? node.root.childNodes : node.childNodes;

      childNodes.forEach(function (child) {
        child.visible = filterNodeMethod.call(child, value, child.data, child);

        traverse(child);
      });

      if (!node.visible && childNodes.length) {
        var allHidden = true;
        allHidden = !childNodes.some(function (child) {
          return child.visible;
        });

        if (node.root) {
          node.root.visible = allHidden === false;
        } else {
          node.visible = allHidden === false;
        }
      }
      if (!value) return;

      if (node.visible && !node.isLeaf && !lazy) node.expand();
    };

    traverse(this);
  };

  TreeStore.prototype.setData = function setData(newVal) {
    var instanceChanged = newVal !== this.root.data;
    if (instanceChanged) {
      this.root.setData(newVal);
      this._initDefaultCheckedNodes();
    } else {
      this.root.updateChildren();
    }
  };

  TreeStore.prototype.getNode = function getNode(data) {
    if (data instanceof model_node) return data;
    var key = (typeof data === 'undefined' ? 'undefined' : _typeof(data)) !== 'object' ? data : util_getNodeKey(this.key, data);
    return this.nodesMap[key] || null;
  };

  TreeStore.prototype.insertBefore = function insertBefore(data, refData) {
    var refNode = this.getNode(refData);
    refNode.parent.insertBefore({ data: data }, refNode);
  };

  TreeStore.prototype.insertAfter = function insertAfter(data, refData) {
    var refNode = this.getNode(refData);
    refNode.parent.insertAfter({ data: data }, refNode);
  };

  TreeStore.prototype.remove = function remove(data) {
    var node = this.getNode(data);

    if (node && node.parent) {
      if (node === this.currentNode) {
        this.currentNode = null;
      }
      node.parent.removeChild(node);
    }
  };

  TreeStore.prototype.append = function append(data, parentData) {
    var parentNode = parentData ? this.getNode(parentData) : this.root;

    if (parentNode) {
      parentNode.insertChild({ data: data });
    }
  };

  TreeStore.prototype._initDefaultCheckedNodes = function _initDefaultCheckedNodes() {
    var _this2 = this;

    var defaultCheckedKeys = this.defaultCheckedKeys || [];
    var nodesMap = this.nodesMap;

    defaultCheckedKeys.forEach(function (checkedKey) {
      var node = nodesMap[checkedKey];

      if (node) {
        node.setChecked(true, !_this2.checkStrictly);
      }
    });
  };

  TreeStore.prototype._initDefaultCheckedNode = function _initDefaultCheckedNode(node) {
    var defaultCheckedKeys = this.defaultCheckedKeys || [];

    if (defaultCheckedKeys.indexOf(node.key) !== -1) {
      node.setChecked(true, !this.checkStrictly);
    }
  };

  TreeStore.prototype.setDefaultCheckedKey = function setDefaultCheckedKey(newVal) {
    if (newVal !== this.defaultCheckedKeys) {
      this.defaultCheckedKeys = newVal;
      this._initDefaultCheckedNodes();
    }
  };

  TreeStore.prototype.registerNode = function registerNode(node) {
    var key = this.key;
    if (!key || !node || !node.data) return;

    var nodeKey = node.key;
    if (nodeKey !== undefined) this.nodesMap[node.key] = node;
  };

  TreeStore.prototype.deregisterNode = function deregisterNode(node) {
    var _this3 = this;

    var key = this.key;
    if (!key || !node || !node.data) return;

    node.childNodes.forEach(function (child) {
      _this3.deregisterNode(child);
    });

    delete this.nodesMap[node.key];
  };

  TreeStore.prototype.getCheckedNodes = function getCheckedNodes() {
    var leafOnly = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
    var includeHalfChecked = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;

    var checkedNodes = [];
    var traverse = function traverse(node) {
      var childNodes = node.root ? node.root.childNodes : node.childNodes;

      childNodes.forEach(function (child) {
        if ((child.checked || includeHalfChecked && child.indeterminate) && (!leafOnly || leafOnly && child.isLeaf)) {
          checkedNodes.push(child.data);
        }

        traverse(child);
      });
    };

    traverse(this);

    return checkedNodes;
  };

  TreeStore.prototype.getCheckedKeys = function getCheckedKeys() {
    var _this4 = this;

    var leafOnly = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;

    return this.getCheckedNodes(leafOnly).map(function (data) {
      return (data || {})[_this4.key];
    });
  };

  TreeStore.prototype.getHalfCheckedNodes = function getHalfCheckedNodes() {
    var nodes = [];
    var traverse = function traverse(node) {
      var childNodes = node.root ? node.root.childNodes : node.childNodes;

      childNodes.forEach(function (child) {
        if (child.indeterminate) {
          nodes.push(child.data);
        }

        traverse(child);
      });
    };

    traverse(this);

    return nodes;
  };

  TreeStore.prototype.getHalfCheckedKeys = function getHalfCheckedKeys() {
    var _this5 = this;

    return this.getHalfCheckedNodes().map(function (data) {
      return (data || {})[_this5.key];
    });
  };

  TreeStore.prototype._getAllNodes = function _getAllNodes() {
    var allNodes = [];
    var nodesMap = this.nodesMap;
    for (var nodeKey in nodesMap) {
      if (nodesMap.hasOwnProperty(nodeKey)) {
        allNodes.push(nodesMap[nodeKey]);
      }
    }

    return allNodes;
  };

  TreeStore.prototype.updateChildren = function updateChildren(key, data) {
    var node = this.nodesMap[key];
    if (!node) return;
    var childNodes = node.childNodes;
    for (var i = childNodes.length - 1; i >= 0; i--) {
      var child = childNodes[i];
      this.remove(child.data);
    }
    for (var _i = 0, j = data.length; _i < j; _i++) {
      var _child = data[_i];
      this.append(_child, node.data);
    }
  };

  TreeStore.prototype._setCheckedKeys = function _setCheckedKeys(key) {
    var leafOnly = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
    var checkedKeys = arguments[2];

    var allNodes = this._getAllNodes().sort(function (a, b) {
      return b.level - a.level;
    });
    var cache = Object.create(null);
    var keys = Object.keys(checkedKeys);
    allNodes.forEach(function (node) {
      return node.setChecked(false, false);
    });
    for (var i = 0, j = allNodes.length; i < j; i++) {
      var node = allNodes[i];
      var nodeKey = node.data[key].toString();
      var checked = keys.indexOf(nodeKey) > -1;
      if (!checked) {
        if (node.checked && !cache[nodeKey]) {
          node.setChecked(false, false);
        }
        continue;
      }

      var parent = node.parent;
      while (parent && parent.level > 0) {
        cache[parent.data[key]] = true;
        parent = parent.parent;
      }

      if (node.isLeaf || this.checkStrictly) {
        node.setChecked(true, false);
        continue;
      }
      node.setChecked(true, true);

      if (leafOnly) {
        (function () {
          node.setChecked(false, false);
          var traverse = function traverse(node) {
            var childNodes = node.childNodes;
            childNodes.forEach(function (child) {
              if (!child.isLeaf) {
                child.setChecked(false, false);
              }
              traverse(child);
            });
          };
          traverse(node);
        })();
      }
    }
  };

  TreeStore.prototype.setCheckedNodes = function setCheckedNodes(array) {
    var leafOnly = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;

    var key = this.key;
    var checkedKeys = {};
    array.forEach(function (item) {
      checkedKeys[(item || {})[key]] = true;
    });

    this._setCheckedKeys(key, leafOnly, checkedKeys);
  };

  TreeStore.prototype.setCheckedKeys = function setCheckedKeys(keys) {
    var leafOnly = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;

    this.defaultCheckedKeys = keys;
    var key = this.key;
    var checkedKeys = {};
    keys.forEach(function (key) {
      checkedKeys[key] = true;
    });

    this._setCheckedKeys(key, leafOnly, checkedKeys);
  };

  TreeStore.prototype.setDefaultExpandedKeys = function setDefaultExpandedKeys(keys) {
    var _this6 = this;

    keys = keys || [];
    this.defaultExpandedKeys = keys;

    keys.forEach(function (key) {
      var node = _this6.getNode(key);
      if (node) node.expand(null, _this6.autoExpandParent);
    });
  };

  TreeStore.prototype.setChecked = function setChecked(data, checked, deep) {
    var node = this.getNode(data);

    if (node) {
      node.setChecked(!!checked, deep);
    }
  };

  TreeStore.prototype.getCurrentNode = function getCurrentNode() {
    return this.currentNode;
  };

  TreeStore.prototype.setCurrentNode = function setCurrentNode(currentNode) {
    var prevCurrentNode = this.currentNode;
    if (prevCurrentNode) {
      prevCurrentNode.isCurrent = false;
    }
    this.currentNode = currentNode;
    this.currentNode.isCurrent = true;
  };

  TreeStore.prototype.setUserCurrentNode = function setUserCurrentNode(node) {
    var key = node[this.key];
    var currNode = this.nodesMap[key];
    this.setCurrentNode(currNode);
  };

  TreeStore.prototype.setCurrentNodeKey = function setCurrentNodeKey(key) {
    if (key === null || key === undefined) {
      this.currentNode && (this.currentNode.isCurrent = false);
      this.currentNode = null;
      return;
    }
    var node = this.getNode(key);
    if (node) {
      this.setCurrentNode(node);
    }
  };

  return TreeStore;
}();

/* harmony default export */ var tree_store = (tree_store_TreeStore);
;
// CONCATENATED MODULE: ./node_modules/vue-loader/lib/loaders/templateLoader.js??vue-loader-options!./node_modules/vue-loader/lib??vue-loader-options!./packages/tree/src/tree-node.vue?vue&type=template&id=3ba3ef0e&
var tree_nodevue_type_template_id_3ba3ef0e_render = function() {
  var this$1 = this
  var _vm = this
  var _h = _vm.$createElement
  var _c = _vm._self._c || _h
  return _c(
    "div",
    {
      directives: [
        {
          name: "show",
          rawName: "v-show",
          value: _vm.node.visible,
          expression: "node.visible"
        }
      ],
      ref: "node",
      staticClass: "el-tree-node",
      class: {
        "is-expanded": _vm.expanded,
        "is-current": _vm.node.isCurrent,
        "is-hidden": !_vm.node.visible,
        "is-focusable": !_vm.node.disabled,
        "is-checked": !_vm.node.disabled && _vm.node.checked
      },
      attrs: {
        role: "treeitem",
        tabindex: "-1",
        "aria-expanded": _vm.expanded,
        "aria-disabled": _vm.node.disabled,
        "aria-checked": _vm.node.checked,
        draggable: _vm.tree.draggable
      },
      on: {
        click: function($event) {
          $event.stopPropagation()
          return _vm.handleClick($event)
        },
        contextmenu: function($event) {
          return this$1.handleContextMenu($event)
        },
        dragstart: function($event) {
          $event.stopPropagation()
          return _vm.handleDragStart($event)
        },
        dragover: function($event) {
          $event.stopPropagation()
          return _vm.handleDragOver($event)
        },
        dragend: function($event) {
          $event.stopPropagation()
          return _vm.handleDragEnd($event)
        },
        drop: function($event) {
          $event.stopPropagation()
          return _vm.handleDrop($event)
        }
      }
    },
    [
      _c(
        "div",
        {
          staticClass: "el-tree-node__content",
          style: {
            "padding-left": (_vm.node.level - 1) * _vm.tree.indent + "px"
          }
        },
        [
          _c("span", {
            class: [
              {
                "is-leaf": _vm.node.isLeaf,
                expanded: !_vm.node.isLeaf && _vm.expanded
              },
              "el-tree-node__expand-icon",
              _vm.tree.iconClass ? _vm.tree.iconClass : "el-icon-caret-right"
            ],
            on: {
              click: function($event) {
                $event.stopPropagation()
                return _vm.handleExpandIconClick($event)
              }
            }
          }),
          _vm.showCheckbox
            ? _c("el-checkbox", {
                attrs: {
                  indeterminate: _vm.node.indeterminate,
                  disabled: !!_vm.node.disabled
                },
                on: { change: _vm.handleCheckChange },
                nativeOn: {
                  click: function($event) {
                    $event.stopPropagation()
                  }
                },
                model: {
                  value: _vm.node.checked,
                  callback: function($$v) {
                    _vm.$set(_vm.node, "checked", $$v)
                  },
                  expression: "node.checked"
                }
              })
            : _vm._e(),
          _vm.node.loading
            ? _c("span", {
                staticClass: "el-tree-node__loading-icon el-icon-loading"
              })
            : _vm._e(),
          _c("node-content", { attrs: { node: _vm.node } })
        ],
        1
      ),
      _c("el-collapse-transition", [
        !_vm.renderAfterExpand || _vm.childNodeRendered
          ? _c(
              "div",
              {
                directives: [
                  {
                    name: "show",
                    rawName: "v-show",
                    value: _vm.expanded,
                    expression: "expanded"
                  }
                ],
                staticClass: "el-tree-node__children",
                attrs: { role: "group", "aria-expanded": _vm.expanded }
              },
              _vm._l(_vm.node.childNodes, function(child) {
                return _c("el-tree-node", {
                  key: _vm.getNodeKey(child),
                  attrs: {
                    "render-content": _vm.renderContent,
                    "render-after-expand": _vm.renderAfterExpand,
                    "show-checkbox": _vm.showCheckbox,
                    node: child
                  },
                  on: { "node-expand": _vm.handleChildNodeExpand }
                })
              }),
              1
            )
          : _vm._e()
      ])
    ],
    1
  )
}
var tree_nodevue_type_template_id_3ba3ef0e_staticRenderFns = []
tree_nodevue_type_template_id_3ba3ef0e_render._withStripped = true


// CONCATENATED MODULE: ./packages/tree/src/tree-node.vue?vue&type=template&id=3ba3ef0e&

// EXTERNAL MODULE: external "forever-zu/lib/transitions/collapse-transition"
var collapse_transition_ = __webpack_require__(35);
var collapse_transition_default = /*#__PURE__*/__webpack_require__.n(collapse_transition_);

// EXTERNAL MODULE: external "forever-zu/lib/checkbox"
var checkbox_ = __webpack_require__(21);
var checkbox_default = /*#__PURE__*/__webpack_require__.n(checkbox_);

// EXTERNAL MODULE: external "forever-zu/lib/mixins/emitter"
var emitter_ = __webpack_require__(4);
var emitter_default = /*#__PURE__*/__webpack_require__.n(emitter_);

// CONCATENATED MODULE: ./node_modules/babel-loader/lib!./node_modules/vue-loader/lib??vue-loader-options!./packages/tree/src/tree-node.vue?vue&type=script&lang=js&
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//






/* harmony default export */ var tree_nodevue_type_script_lang_js_ = ({
  name: 'ElTreeNode',

  componentName: 'ElTreeNode',

  mixins: [emitter_default.a],

  props: {
    node: {
      default: function _default() {
        return {};
      }
    },
    props: {},
    renderContent: Function,
    renderAfterExpand: {
      type: Boolean,
      default: true
    },
    showCheckbox: {
      type: Boolean,
      default: false
    }
  },

  components: {
    ElCollapseTransition: collapse_transition_default.a,
    ElCheckbox: checkbox_default.a,
    NodeContent: {
      props: {
        node: {
          required: true
        }
      },
      render: function render(h) {
        var parent = this.$parent;
        var tree = parent.tree;
        var node = this.node;
        var data = node.data,
            store = node.store;

        return parent.renderContent ? parent.renderContent.call(parent._renderProxy, h, { _self: tree.$vnode.context, node: node, data: data, store: store }) : tree.$scopedSlots.default ? tree.$scopedSlots.default({ node: node, data: data }) : h(
          'span',
          { 'class': 'el-tree-node__label' },
          [node.label]
        );
      }
    }
  },

  data: function data() {
    return {
      tree: null,
      expanded: false,
      childNodeRendered: false,
      oldChecked: null,
      oldIndeterminate: null
    };
  },


  watch: {
    'node.indeterminate': function nodeIndeterminate(val) {
      this.handleSelectChange(this.node.checked, val);
    },
    'node.checked': function nodeChecked(val) {
      this.handleSelectChange(val, this.node.indeterminate);
    },
    'node.expanded': function nodeExpanded(val) {
      var _this = this;

      this.$nextTick(function () {
        return _this.expanded = val;
      });
      if (val) {
        this.childNodeRendered = true;
      }
    }
  },

  methods: {
    getNodeKey: function getNodeKey(node) {
      return util_getNodeKey(this.tree.nodeKey, node.data);
    },
    handleSelectChange: function handleSelectChange(checked, indeterminate) {
      if (this.oldChecked !== checked && this.oldIndeterminate !== indeterminate) {
        this.tree.$emit('check-change', this.node.data, checked, indeterminate);
      }
      this.oldChecked = checked;
      this.indeterminate = indeterminate;
    },
    handleClick: function handleClick() {
      var store = this.tree.store;
      store.setCurrentNode(this.node);
      this.tree.$emit('current-change', store.currentNode ? store.currentNode.data : null, store.currentNode);
      this.tree.currentNode = this;
      if (this.tree.expandOnClickNode) {
        this.handleExpandIconClick();
      }
      if (this.tree.checkOnClickNode && !this.node.disabled) {
        this.handleCheckChange(null, {
          target: { checked: !this.node.checked }
        });
      }
      this.tree.$emit('node-click', this.node.data, this.node, this);
    },
    handleContextMenu: function handleContextMenu(event) {
      if (this.tree._events['node-contextmenu'] && this.tree._events['node-contextmenu'].length > 0) {
        event.stopPropagation();
        event.preventDefault();
      }
      this.tree.$emit('node-contextmenu', event, this.node.data, this.node, this);
    },
    handleExpandIconClick: function handleExpandIconClick() {
      if (this.node.isLeaf) return;
      if (this.expanded) {
        this.tree.$emit('node-collapse', this.node.data, this.node, this);
        this.node.collapse();
      } else {
        this.node.expand();
        this.$emit('node-expand', this.node.data, this.node, this);
      }
    },
    handleCheckChange: function handleCheckChange(value, ev) {
      var _this2 = this;

      this.node.setChecked(ev.target.checked, !this.tree.checkStrictly);
      this.$nextTick(function () {
        var store = _this2.tree.store;
        _this2.tree.$emit('check', _this2.node.data, {
          checkedNodes: store.getCheckedNodes(),
          checkedKeys: store.getCheckedKeys(),
          halfCheckedNodes: store.getHalfCheckedNodes(),
          halfCheckedKeys: store.getHalfCheckedKeys()
        });
      });
    },
    handleChildNodeExpand: function handleChildNodeExpand(nodeData, node, instance) {
      this.broadcast('ElTreeNode', 'tree-node-expand', node);
      this.tree.$emit('node-expand', nodeData, node, instance);
    },
    handleDragStart: function handleDragStart(event) {
      if (!this.tree.draggable) return;
      this.tree.$emit('tree-node-drag-start', event, this);
    },
    handleDragOver: function handleDragOver(event) {
      if (!this.tree.draggable) return;
      this.tree.$emit('tree-node-drag-over', event, this);
      event.preventDefault();
    },
    handleDrop: function handleDrop(event) {
      event.preventDefault();
    },
    handleDragEnd: function handleDragEnd(event) {
      if (!this.tree.draggable) return;
      this.tree.$emit('tree-node-drag-end', event, this);
    }
  },

  created: function created() {
    var _this3 = this;

    var parent = this.$parent;

    if (parent.isTree) {
      this.tree = parent;
    } else {
      this.tree = parent.tree;
    }

    var tree = this.tree;
    if (!tree) {
      console.warn('Can not find node\'s tree.');
    }

    var props = tree.props || {};
    var childrenKey = props['children'] || 'children';

    this.$watch('node.data.' + childrenKey, function () {
      _this3.node.updateChildren();
    });

    if (this.node.expanded) {
      this.expanded = true;
      this.childNodeRendered = true;
    }

    if (this.tree.accordion) {
      this.$on('tree-node-expand', function (node) {
        if (_this3.node !== node) {
          _this3.node.collapse();
        }
      });
    }
  }
});
// CONCATENATED MODULE: ./packages/tree/src/tree-node.vue?vue&type=script&lang=js&
 /* harmony default export */ var src_tree_nodevue_type_script_lang_js_ = (tree_nodevue_type_script_lang_js_); 
// EXTERNAL MODULE: ./node_modules/vue-loader/lib/runtime/componentNormalizer.js
var componentNormalizer = __webpack_require__(0);

// CONCATENATED MODULE: ./packages/tree/src/tree-node.vue





/* normalize component */

var component = Object(componentNormalizer["a" /* default */])(
  src_tree_nodevue_type_script_lang_js_,
  tree_nodevue_type_template_id_3ba3ef0e_render,
  tree_nodevue_type_template_id_3ba3ef0e_staticRenderFns,
  false,
  null,
  null,
  null
  
)

/* hot reload */
if (false) { var api; }
component.options.__file = "packages/tree/src/tree-node.vue"
/* harmony default export */ var tree_node = (component.exports);
// EXTERNAL MODULE: external "forever-zu/lib/locale"
var locale_ = __webpack_require__(25);

// EXTERNAL MODULE: external "forever-zu/lib/utils/dom"
var dom_ = __webpack_require__(2);

// CONCATENATED MODULE: ./node_modules/babel-loader/lib!./node_modules/vue-loader/lib??vue-loader-options!./packages/tree/src/tree.vue?vue&type=script&lang=js&
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//








/* harmony default export */ var treevue_type_script_lang_js_ = ({
  name: 'ElTree',

  mixins: [emitter_default.a],

  components: {
    ElTreeNode: tree_node
  },

  data: function data() {
    return {
      store: null,
      root: null,
      currentNode: null,
      treeItems: null,
      checkboxItems: [],
      dragState: {
        showDropIndicator: false,
        draggingNode: null,
        dropNode: null,
        allowDrop: true
      }
    };
  },


  props: {
    data: {
      type: Array
    },
    emptyText: {
      type: String,
      default: function _default() {
        return Object(locale_["t"])('el.tree.emptyText');
      }
    },
    renderAfterExpand: {
      type: Boolean,
      default: true
    },
    nodeKey: String,
    checkStrictly: Boolean,
    defaultExpandAll: Boolean,
    expandOnClickNode: {
      type: Boolean,
      default: true
    },
    checkOnClickNode: Boolean,
    checkDescendants: {
      type: Boolean,
      default: false
    },
    autoExpandParent: {
      type: Boolean,
      default: true
    },
    defaultCheckedKeys: Array,
    defaultExpandedKeys: Array,
    currentNodeKey: [String, Number],
    renderContent: Function,
    showCheckbox: {
      type: Boolean,
      default: false
    },
    draggable: {
      type: Boolean,
      default: false
    },
    allowDrag: Function,
    allowDrop: Function,
    props: {
      default: function _default() {
        return {
          children: 'children',
          label: 'label',
          disabled: 'disabled'
        };
      }
    },
    lazy: {
      type: Boolean,
      default: false
    },
    highlightCurrent: Boolean,
    load: Function,
    filterNodeMethod: Function,
    accordion: Boolean,
    indent: {
      type: Number,
      default: 18
    },
    iconClass: String
  },

  computed: {
    children: {
      set: function set(value) {
        this.data = value;
      },
      get: function get() {
        return this.data;
      }
    },

    treeItemArray: function treeItemArray() {
      return Array.prototype.slice.call(this.treeItems);
    },
    isEmpty: function isEmpty() {
      var childNodes = this.root.childNodes;

      return !childNodes || childNodes.length === 0 || childNodes.every(function (_ref) {
        var visible = _ref.visible;
        return !visible;
      });
    }
  },

  watch: {
    defaultCheckedKeys: function defaultCheckedKeys(newVal) {
      this.store.setDefaultCheckedKey(newVal);
    },
    defaultExpandedKeys: function defaultExpandedKeys(newVal) {
      this.store.defaultExpandedKeys = newVal;
      this.store.setDefaultExpandedKeys(newVal);
    },
    data: function data(newVal) {
      this.store.setData(newVal);
    },
    checkboxItems: function checkboxItems(val) {
      Array.prototype.forEach.call(val, function (checkbox) {
        checkbox.setAttribute('tabindex', -1);
      });
    },
    checkStrictly: function checkStrictly(newVal) {
      this.store.checkStrictly = newVal;
    }
  },

  methods: {
    filter: function filter(value) {
      if (!this.filterNodeMethod) throw new Error('[Tree] filterNodeMethod is required when filter');
      this.store.filter(value);
    },
    getNodeKey: function getNodeKey(node) {
      return util_getNodeKey(this.nodeKey, node.data);
    },
    getNodePath: function getNodePath(data) {
      if (!this.nodeKey) throw new Error('[Tree] nodeKey is required in getNodePath');
      var node = this.store.getNode(data);
      if (!node) return [];
      var path = [node.data];
      var parent = node.parent;
      while (parent && parent !== this.root) {
        path.push(parent.data);
        parent = parent.parent;
      }
      return path.reverse();
    },
    getCheckedNodes: function getCheckedNodes(leafOnly, includeHalfChecked) {
      return this.store.getCheckedNodes(leafOnly, includeHalfChecked);
    },
    getCheckedKeys: function getCheckedKeys(leafOnly) {
      return this.store.getCheckedKeys(leafOnly);
    },
    getCurrentNode: function getCurrentNode() {
      var currentNode = this.store.getCurrentNode();
      return currentNode ? currentNode.data : null;
    },
    getCurrentKey: function getCurrentKey() {
      if (!this.nodeKey) throw new Error('[Tree] nodeKey is required in getCurrentKey');
      var currentNode = this.getCurrentNode();
      return currentNode ? currentNode[this.nodeKey] : null;
    },
    setCheckedNodes: function setCheckedNodes(nodes, leafOnly) {
      if (!this.nodeKey) throw new Error('[Tree] nodeKey is required in setCheckedNodes');
      this.store.setCheckedNodes(nodes, leafOnly);
    },
    setCheckedKeys: function setCheckedKeys(keys, leafOnly) {
      if (!this.nodeKey) throw new Error('[Tree] nodeKey is required in setCheckedKeys');
      this.store.setCheckedKeys(keys, leafOnly);
    },
    setChecked: function setChecked(data, checked, deep) {
      this.store.setChecked(data, checked, deep);
    },
    getHalfCheckedNodes: function getHalfCheckedNodes() {
      return this.store.getHalfCheckedNodes();
    },
    getHalfCheckedKeys: function getHalfCheckedKeys() {
      return this.store.getHalfCheckedKeys();
    },
    setCurrentNode: function setCurrentNode(node) {
      if (!this.nodeKey) throw new Error('[Tree] nodeKey is required in setCurrentNode');
      this.store.setUserCurrentNode(node);
    },
    setCurrentKey: function setCurrentKey(key) {
      if (!this.nodeKey) throw new Error('[Tree] nodeKey is required in setCurrentKey');
      this.store.setCurrentNodeKey(key);
    },
    getNode: function getNode(data) {
      return this.store.getNode(data);
    },
    remove: function remove(data) {
      this.store.remove(data);
    },
    append: function append(data, parentNode) {
      this.store.append(data, parentNode);
    },
    insertBefore: function insertBefore(data, refNode) {
      this.store.insertBefore(data, refNode);
    },
    insertAfter: function insertAfter(data, refNode) {
      this.store.insertAfter(data, refNode);
    },
    handleNodeExpand: function handleNodeExpand(nodeData, node, instance) {
      this.broadcast('ElTreeNode', 'tree-node-expand', node);
      this.$emit('node-expand', nodeData, node, instance);
    },
    updateKeyChildren: function updateKeyChildren(key, data) {
      if (!this.nodeKey) throw new Error('[Tree] nodeKey is required in updateKeyChild');
      this.store.updateChildren(key, data);
    },
    initTabIndex: function initTabIndex() {
      this.treeItems = this.$el.querySelectorAll('.is-focusable[role=treeitem]');
      this.checkboxItems = this.$el.querySelectorAll('input[type=checkbox]');
      var checkedItem = this.$el.querySelectorAll('.is-checked[role=treeitem]');
      if (checkedItem.length) {
        checkedItem[0].setAttribute('tabindex', 0);
        return;
      }
      this.treeItems[0] && this.treeItems[0].setAttribute('tabindex', 0);
    },
    handleKeydown: function handleKeydown(ev) {
      var currentItem = ev.target;
      if (currentItem.className.indexOf('el-tree-node') === -1) return;
      var keyCode = ev.keyCode;
      this.treeItems = this.$el.querySelectorAll('.is-focusable[role=treeitem]');
      var currentIndex = this.treeItemArray.indexOf(currentItem);
      var nextIndex = void 0;
      if ([38, 40].indexOf(keyCode) > -1) {
        // up、down
        ev.preventDefault();
        if (keyCode === 38) {
          // up
          nextIndex = currentIndex !== 0 ? currentIndex - 1 : 0;
        } else {
          nextIndex = currentIndex < this.treeItemArray.length - 1 ? currentIndex + 1 : 0;
        }
        this.treeItemArray[nextIndex].focus(); // 选中
      }
      if ([37, 39].indexOf(keyCode) > -1) {
        // left、right 展开
        ev.preventDefault();
        currentItem.click(); // 选中
      }
      var hasInput = currentItem.querySelector('[type="checkbox"]');
      if ([13, 32].indexOf(keyCode) > -1 && hasInput) {
        // space enter选中checkbox
        ev.preventDefault();
        hasInput.click();
      }
    }
  },

  created: function created() {
    var _this = this;

    this.isTree = true;

    this.store = new tree_store({
      key: this.nodeKey,
      data: this.data,
      lazy: this.lazy,
      props: this.props,
      load: this.load,
      currentNodeKey: this.currentNodeKey,
      checkStrictly: this.checkStrictly,
      checkDescendants: this.checkDescendants,
      defaultCheckedKeys: this.defaultCheckedKeys,
      defaultExpandedKeys: this.defaultExpandedKeys,
      autoExpandParent: this.autoExpandParent,
      defaultExpandAll: this.defaultExpandAll,
      filterNodeMethod: this.filterNodeMethod
    });

    this.root = this.store.root;

    var dragState = this.dragState;
    this.$on('tree-node-drag-start', function (event, treeNode) {
      if (typeof _this.allowDrag === 'function' && !_this.allowDrag(treeNode.node)) {
        event.preventDefault();
        return false;
      }
      event.dataTransfer.effectAllowed = 'move';

      // wrap in try catch to address IE's error when first param is 'text/plain'
      try {
        // setData is required for draggable to work in FireFox
        // the content has to be '' so dragging a node out of the tree won't open a new tab in FireFox
        event.dataTransfer.setData('text/plain', '');
      } catch (e) {}
      dragState.draggingNode = treeNode;
      _this.$emit('node-drag-start', treeNode.node, event);
    });

    this.$on('tree-node-drag-over', function (event, treeNode) {
      var dropNode = findNearestComponent(event.target, 'ElTreeNode');
      var oldDropNode = dragState.dropNode;
      if (oldDropNode && oldDropNode !== dropNode) {
        Object(dom_["removeClass"])(oldDropNode.$el, 'is-drop-inner');
      }
      var draggingNode = dragState.draggingNode;
      if (!draggingNode || !dropNode) return;

      var dropPrev = true;
      var dropInner = true;
      var dropNext = true;
      var userAllowDropInner = true;
      if (typeof _this.allowDrop === 'function') {
        dropPrev = _this.allowDrop(draggingNode.node, dropNode.node, 'prev');
        userAllowDropInner = dropInner = _this.allowDrop(draggingNode.node, dropNode.node, 'inner');
        dropNext = _this.allowDrop(draggingNode.node, dropNode.node, 'next');
      }
      event.dataTransfer.dropEffect = dropInner ? 'move' : 'none';
      if ((dropPrev || dropInner || dropNext) && oldDropNode !== dropNode) {
        if (oldDropNode) {
          _this.$emit('node-drag-leave', draggingNode.node, oldDropNode.node, event);
        }
        _this.$emit('node-drag-enter', draggingNode.node, dropNode.node, event);
      }

      if (dropPrev || dropInner || dropNext) {
        dragState.dropNode = dropNode;
      }

      if (dropNode.node.nextSibling === draggingNode.node) {
        dropNext = false;
      }
      if (dropNode.node.previousSibling === draggingNode.node) {
        dropPrev = false;
      }
      if (dropNode.node.contains(draggingNode.node, false)) {
        dropInner = false;
      }
      if (draggingNode.node === dropNode.node || draggingNode.node.contains(dropNode.node)) {
        dropPrev = false;
        dropInner = false;
        dropNext = false;
      }

      var targetPosition = dropNode.$el.getBoundingClientRect();
      var treePosition = _this.$el.getBoundingClientRect();

      var dropType = void 0;
      var prevPercent = dropPrev ? dropInner ? 0.25 : dropNext ? 0.45 : 1 : -1;
      var nextPercent = dropNext ? dropInner ? 0.75 : dropPrev ? 0.55 : 0 : 1;

      var indicatorTop = -9999;
      var distance = event.clientY - targetPosition.top;
      if (distance < targetPosition.height * prevPercent) {
        dropType = 'before';
      } else if (distance > targetPosition.height * nextPercent) {
        dropType = 'after';
      } else if (dropInner) {
        dropType = 'inner';
      } else {
        dropType = 'none';
      }

      var iconPosition = dropNode.$el.querySelector('.el-tree-node__expand-icon').getBoundingClientRect();
      var dropIndicator = _this.$refs.dropIndicator;
      if (dropType === 'before') {
        indicatorTop = iconPosition.top - treePosition.top;
      } else if (dropType === 'after') {
        indicatorTop = iconPosition.bottom - treePosition.top;
      }
      dropIndicator.style.top = indicatorTop + 'px';
      dropIndicator.style.left = iconPosition.right - treePosition.left + 'px';

      if (dropType === 'inner') {
        Object(dom_["addClass"])(dropNode.$el, 'is-drop-inner');
      } else {
        Object(dom_["removeClass"])(dropNode.$el, 'is-drop-inner');
      }

      dragState.showDropIndicator = dropType === 'before' || dropType === 'after';
      dragState.allowDrop = dragState.showDropIndicator || userAllowDropInner;
      dragState.dropType = dropType;
      _this.$emit('node-drag-over', draggingNode.node, dropNode.node, event);
    });

    this.$on('tree-node-drag-end', function (event) {
      var draggingNode = dragState.draggingNode,
          dropType = dragState.dropType,
          dropNode = dragState.dropNode;

      event.preventDefault();
      event.dataTransfer.dropEffect = 'move';

      if (draggingNode && dropNode) {
        var draggingNodeCopy = { data: draggingNode.node.data };
        if (dropType !== 'none') {
          draggingNode.node.remove();
        }
        if (dropType === 'before') {
          dropNode.node.parent.insertBefore(draggingNodeCopy, dropNode.node);
        } else if (dropType === 'after') {
          dropNode.node.parent.insertAfter(draggingNodeCopy, dropNode.node);
        } else if (dropType === 'inner') {
          dropNode.node.insertChild(draggingNodeCopy);
        }
        if (dropType !== 'none') {
          _this.store.registerNode(draggingNodeCopy);
        }

        Object(dom_["removeClass"])(dropNode.$el, 'is-drop-inner');

        _this.$emit('node-drag-end', draggingNode.node, dropNode.node, dropType, event);
        if (dropType !== 'none') {
          _this.$emit('node-drop', draggingNode.node, dropNode.node, dropType, event);
        }
      }
      if (draggingNode && !dropNode) {
        _this.$emit('node-drag-end', draggingNode.node, null, dropType, event);
      }

      dragState.showDropIndicator = false;
      dragState.draggingNode = null;
      dragState.dropNode = null;
      dragState.allowDrop = true;
    });
  },
  mounted: function mounted() {
    this.initTabIndex();
    this.$el.addEventListener('keydown', this.handleKeydown);
  },
  updated: function updated() {
    this.treeItems = this.$el.querySelectorAll('[role=treeitem]');
    this.checkboxItems = this.$el.querySelectorAll('input[type=checkbox]');
  }
});
// CONCATENATED MODULE: ./packages/tree/src/tree.vue?vue&type=script&lang=js&
 /* harmony default export */ var src_treevue_type_script_lang_js_ = (treevue_type_script_lang_js_); 
// CONCATENATED MODULE: ./packages/tree/src/tree.vue





/* normalize component */

var tree_component = Object(componentNormalizer["a" /* default */])(
  src_treevue_type_script_lang_js_,
  render,
  staticRenderFns,
  false,
  null,
  null,
  null
  
)

/* hot reload */
if (false) { var tree_api; }
tree_component.options.__file = "packages/tree/src/tree.vue"
/* harmony default export */ var tree = (tree_component.exports);
// CONCATENATED MODULE: ./packages/tree/index.js


/* istanbul ignore next */
tree.install = function (Vue) {
  Vue.component(tree.name, tree);
};

/* harmony default export */ var packages_tree = __webpack_exports__["default"] = (tree);

/***/ }),
/* 58 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";
// ESM COMPAT FLAG
__webpack_require__.r(__webpack_exports__);

// CONCATENATED MODULE: ./node_modules/vue-loader/lib/loaders/templateLoader.js??vue-loader-options!./node_modules/vue-loader/lib??vue-loader-options!./packages/radio/src/radio-group.vue?vue&type=template&id=818a704c&
var render = function() {
  var _vm = this
  var _h = _vm.$createElement
  var _c = _vm._self._c || _h
  return _c(
    _vm._elTag,
    {
      tag: "component",
      staticClass: "el-radio-group",
      attrs: { role: "radiogroup" },
      on: { keydown: _vm.handleKeydown }
    },
    [_vm._t("default")],
    2
  )
}
var staticRenderFns = []
render._withStripped = true


// CONCATENATED MODULE: ./packages/radio/src/radio-group.vue?vue&type=template&id=818a704c&

// EXTERNAL MODULE: external "forever-zu/lib/mixins/emitter"
var emitter_ = __webpack_require__(4);
var emitter_default = /*#__PURE__*/__webpack_require__.n(emitter_);

// CONCATENATED MODULE: ./node_modules/babel-loader/lib!./node_modules/vue-loader/lib??vue-loader-options!./packages/radio/src/radio-group.vue?vue&type=script&lang=js&
//
//
//
//
//
//
//
//
//
//
//



var keyCode = Object.freeze({
  LEFT: 37,
  UP: 38,
  RIGHT: 39,
  DOWN: 40
});
/* harmony default export */ var radio_groupvue_type_script_lang_js_ = ({
  name: 'ElRadioGroup',
  componentName: 'ElRadioGroup',
  inject: {
    elFormItem: {
      default: ''
    }
  },

  mixins: [emitter_default.a],

  props: {
    value: {},
    size: String,
    fill: String,
    textColor: String,
    disabled: Boolean
  },

  computed: {
    _elFormItemSize: function _elFormItemSize() {
      return (this.elFormItem || {}).elFormItemSize;
    },
    _elTag: function _elTag() {
      return (this.$vnode.data || {}).tag || 'div';
    },
    radioGroupSize: function radioGroupSize() {
      return this.size || this._elFormItemSize || (this.$ELEMENT || {}).size;
    }
  },

  created: function created() {
    var _this = this;

    this.$on('handleChange', function (value) {
      _this.$emit('change', value);
    });
  },
  mounted: function mounted() {
    // 当radioGroup没有默认选项时，第一个可以选中Tab导航
    var radios = this.$el.querySelectorAll('[type=radio]');
    var firstLabel = this.$el.querySelectorAll('[role=radio]')[0];
    if (![].some.call(radios, function (radio) {
      return radio.checked;
    }) && firstLabel) {
      firstLabel.tabIndex = 0;
    }
  },

  methods: {
    handleKeydown: function handleKeydown(e) {
      // 左右上下按键 可以在radio组内切换不同选项
      var target = e.target;
      var className = target.nodeName === 'INPUT' ? '[type=radio]' : '[role=radio]';
      var radios = this.$el.querySelectorAll(className);
      var length = radios.length;
      var index = [].indexOf.call(radios, target);
      var roleRadios = this.$el.querySelectorAll('[role=radio]');
      switch (e.keyCode) {
        case keyCode.LEFT:
        case keyCode.UP:
          e.stopPropagation();
          e.preventDefault();
          if (index === 0) {
            roleRadios[length - 1].click();
            roleRadios[length - 1].focus();
          } else {
            roleRadios[index - 1].click();
            roleRadios[index - 1].focus();
          }
          break;
        case keyCode.RIGHT:
        case keyCode.DOWN:
          if (index === length - 1) {
            e.stopPropagation();
            e.preventDefault();
            roleRadios[0].click();
            roleRadios[0].focus();
          } else {
            roleRadios[index + 1].click();
            roleRadios[index + 1].focus();
          }
          break;
        default:
          break;
      }
    }
  },
  watch: {
    value: function value(_value) {
      this.dispatch('ElFormItem', 'el.form.change', [this.value]);
    }
  }
});
// CONCATENATED MODULE: ./packages/radio/src/radio-group.vue?vue&type=script&lang=js&
 /* harmony default export */ var src_radio_groupvue_type_script_lang_js_ = (radio_groupvue_type_script_lang_js_); 
// EXTERNAL MODULE: ./node_modules/vue-loader/lib/runtime/componentNormalizer.js
var componentNormalizer = __webpack_require__(0);

// CONCATENATED MODULE: ./packages/radio/src/radio-group.vue





/* normalize component */

var component = Object(componentNormalizer["a" /* default */])(
  src_radio_groupvue_type_script_lang_js_,
  render,
  staticRenderFns,
  false,
  null,
  null,
  null
  
)

/* hot reload */
if (false) { var api; }
component.options.__file = "packages/radio/src/radio-group.vue"
/* harmony default export */ var radio_group = (component.exports);
// CONCATENATED MODULE: ./packages/radio-group/index.js


/* istanbul ignore next */
radio_group.install = function (Vue) {
  Vue.component(radio_group.name, radio_group);
};

/* harmony default export */ var packages_radio_group = __webpack_exports__["default"] = (radio_group);

/***/ }),
/* 59 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";
// ESM COMPAT FLAG
__webpack_require__.r(__webpack_exports__);

// CONCATENATED MODULE: ./node_modules/vue-loader/lib/loaders/templateLoader.js??vue-loader-options!./node_modules/vue-loader/lib??vue-loader-options!./packages/checkbox/src/checkbox-group.vue?vue&type=template&id=7289a290&
var render = function() {
  var _vm = this
  var _h = _vm.$createElement
  var _c = _vm._self._c || _h
  return _c(
    "div",
    {
      staticClass: "el-checkbox-group",
      attrs: { role: "group", "aria-label": "checkbox-group" }
    },
    [_vm._t("default")],
    2
  )
}
var staticRenderFns = []
render._withStripped = true


// CONCATENATED MODULE: ./packages/checkbox/src/checkbox-group.vue?vue&type=template&id=7289a290&

// EXTERNAL MODULE: external "forever-zu/lib/mixins/emitter"
var emitter_ = __webpack_require__(4);
var emitter_default = /*#__PURE__*/__webpack_require__.n(emitter_);

// CONCATENATED MODULE: ./node_modules/babel-loader/lib!./node_modules/vue-loader/lib??vue-loader-options!./packages/checkbox/src/checkbox-group.vue?vue&type=script&lang=js&



/* harmony default export */ var checkbox_groupvue_type_script_lang_js_ = ({
  name: 'ElCheckboxGroup',

  componentName: 'ElCheckboxGroup',

  mixins: [emitter_default.a],

  inject: {
    elFormItem: {
      default: ''
    }
  },

  props: {
    value: {},
    disabled: Boolean,
    min: Number,
    max: Number,
    size: String,
    fill: String,
    textColor: String
  },

  computed: {
    _elFormItemSize: function _elFormItemSize() {
      return (this.elFormItem || {}).elFormItemSize;
    },
    checkboxGroupSize: function checkboxGroupSize() {
      return this.size || this._elFormItemSize || (this.$ELEMENT || {}).size;
    }
  },

  watch: {
    value: function value(_value) {
      this.dispatch('ElFormItem', 'el.form.change', [_value]);
    }
  }
});
// CONCATENATED MODULE: ./packages/checkbox/src/checkbox-group.vue?vue&type=script&lang=js&
 /* harmony default export */ var src_checkbox_groupvue_type_script_lang_js_ = (checkbox_groupvue_type_script_lang_js_); 
// EXTERNAL MODULE: ./node_modules/vue-loader/lib/runtime/componentNormalizer.js
var componentNormalizer = __webpack_require__(0);

// CONCATENATED MODULE: ./packages/checkbox/src/checkbox-group.vue





/* normalize component */

var component = Object(componentNormalizer["a" /* default */])(
  src_checkbox_groupvue_type_script_lang_js_,
  render,
  staticRenderFns,
  false,
  null,
  null,
  null
  
)

/* hot reload */
if (false) { var api; }
component.options.__file = "packages/checkbox/src/checkbox-group.vue"
/* harmony default export */ var checkbox_group = (component.exports);
// CONCATENATED MODULE: ./packages/checkbox-group/index.js


/* istanbul ignore next */
checkbox_group.install = function (Vue) {
  Vue.component(checkbox_group.name, checkbox_group);
};

/* harmony default export */ var packages_checkbox_group = __webpack_exports__["default"] = (checkbox_group);

/***/ }),
/* 60 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";
// ESM COMPAT FLAG
__webpack_require__.r(__webpack_exports__);

// CONCATENATED MODULE: ./packages/row/src/row.js
/* harmony default export */ var row = ({
  name: 'ElRow',

  componentName: 'ElRow',

  props: {
    tag: {
      type: String,
      default: 'div'
    },
    gutter: Number,
    type: String,
    justify: {
      type: String,
      default: 'start'
    },
    align: {
      type: String,
      default: 'top'
    }
  },

  computed: {
    style: function style() {
      var ret = {};

      if (this.gutter) {
        ret.marginLeft = '-' + this.gutter / 2 + 'px';
        ret.marginRight = ret.marginLeft;
      }

      return ret;
    }
  },

  render: function render(h) {
    return h(this.tag, {
      class: ['el-row', this.justify !== 'start' ? 'is-justify-' + this.justify : '', this.align !== 'top' ? 'is-align-' + this.align : '', { 'el-row--flex': this.type === 'flex' }],
      style: this.style
    }, this.$slots.default);
  }
});
// CONCATENATED MODULE: ./packages/row/index.js


/* istanbul ignore next */
row.install = function (Vue) {
  Vue.component(row.name, row);
};

/* harmony default export */ var packages_row = __webpack_exports__["default"] = (row);

/***/ }),
/* 61 */,
/* 62 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";
/* unused harmony export toJson */
/* unused harmony export parseJson */
/* harmony import */ var _deepextend__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(28);
/* harmony import */ var _console__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(29);
/* eslint-disable no-eval */



var PREFIX = '[[FORM-CREATE-PREFIX-';
var SUFFIX = '-FORM-CREATE-SUFFIX]]';

function toJson(obj) {
  return JSON.stringify(Object(_deepextend__WEBPACK_IMPORTED_MODULE_0__[/* default */ "b"])([], obj, true), function (key, val) {
    if (val && val._isVue === true) {
      return undefined;
    }

    if (typeof val !== 'function') {
      return val;
    }
    if (val.__inject) {
      val = val.__origin;
    }

    if (val.__emit) {
      return undefined;
    }

    return PREFIX + val + SUFFIX;
  });
}

function makeFn(fn) {
  return eval('(function(){return ' + fn + ' })()');
}

function parseJson(json, mode) {
  return JSON.parse(json, function (k, v) {
    if (!v || !v.indexOf) return v;
    try {
      if (v.indexOf(SUFFIX) > 0 && v.indexOf(PREFIX) === 0) {
        v = v.replace(SUFFIX, '').replace(PREFIX, '');
        return makeFn(v.indexOf('function') === -1 && v.indexOf('(') !== 0 ? 'function ' + v : v);
      } else if (!mode && v.indexOf('function') > -1) {
        return makeFn(v);
      };
    } catch (e) {
      Object(_console__WEBPACK_IMPORTED_MODULE_1__[/* err */ "a"])('json \u89E3\u6790\u5931\u8D25:' + v);
      return undefined;
    }
    return v;
  });
}

/***/ }),
/* 63 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";
// ESM COMPAT FLAG
__webpack_require__.r(__webpack_exports__);

// CONCATENATED MODULE: ./node_modules/vue-loader/lib/loaders/templateLoader.js??vue-loader-options!./node_modules/vue-loader/lib??vue-loader-options!./packages/progress/src/progress.vue?vue&type=template&id=229ee406&
var render = function() {
  var _vm = this
  var _h = _vm.$createElement
  var _c = _vm._self._c || _h
  return _c(
    "div",
    {
      staticClass: "el-progress",
      class: [
        "el-progress--" + _vm.type,
        _vm.status ? "is-" + _vm.status : "",
        {
          "el-progress--without-text": !_vm.showText,
          "el-progress--text-inside": _vm.textInside
        }
      ],
      attrs: {
        role: "progressbar",
        "aria-valuenow": _vm.percentage,
        "aria-valuemin": "0",
        "aria-valuemax": "100"
      }
    },
    [
      _vm.type === "line"
        ? _c("div", { staticClass: "el-progress-bar" }, [
            _c(
              "div",
              {
                staticClass: "el-progress-bar__outer",
                style: { height: _vm.strokeWidth + "px" }
              },
              [
                _c(
                  "div",
                  {
                    staticClass: "el-progress-bar__inner",
                    style: _vm.barStyle
                  },
                  [
                    _vm.showText && _vm.textInside
                      ? _c(
                          "div",
                          { staticClass: "el-progress-bar__innerText" },
                          [_vm._v(_vm._s(_vm.content))]
                        )
                      : _vm._e()
                  ]
                )
              ]
            )
          ])
        : _c(
            "div",
            {
              staticClass: "el-progress-circle",
              style: { height: _vm.width + "px", width: _vm.width + "px" }
            },
            [
              _c("svg", { attrs: { viewBox: "0 0 100 100" } }, [
                _c("path", {
                  staticClass: "el-progress-circle__track",
                  style: _vm.trailPathStyle,
                  attrs: {
                    d: _vm.trackPath,
                    stroke: "#e5e9f2",
                    "stroke-width": _vm.relativeStrokeWidth,
                    fill: "none"
                  }
                }),
                _c("path", {
                  staticClass: "el-progress-circle__path",
                  style: _vm.circlePathStyle,
                  attrs: {
                    d: _vm.trackPath,
                    stroke: _vm.stroke,
                    fill: "none",
                    "stroke-linecap": _vm.strokeLinecap,
                    "stroke-width": _vm.percentage ? _vm.relativeStrokeWidth : 0
                  }
                })
              ])
            ]
          ),
      _vm.showText && !_vm.textInside
        ? _c(
            "div",
            {
              staticClass: "el-progress__text",
              style: { fontSize: _vm.progressTextSize + "px" }
            },
            [
              !_vm.status
                ? [_vm._v(_vm._s(_vm.content))]
                : _c("i", { class: _vm.iconClass })
            ],
            2
          )
        : _vm._e()
    ]
  )
}
var staticRenderFns = []
render._withStripped = true


// CONCATENATED MODULE: ./packages/progress/src/progress.vue?vue&type=template&id=229ee406&

// CONCATENATED MODULE: ./node_modules/babel-loader/lib!./node_modules/vue-loader/lib??vue-loader-options!./packages/progress/src/progress.vue?vue&type=script&lang=js&
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//

/* harmony default export */ var progressvue_type_script_lang_js_ = ({
  name: 'ElProgress',
  props: {
    type: {
      type: String,
      default: 'line',
      validator: function validator(val) {
        return ['line', 'circle', 'dashboard'].indexOf(val) > -1;
      }
    },
    percentage: {
      type: Number,
      default: 0,
      required: true,
      validator: function validator(val) {
        return val >= 0 && val <= 100;
      }
    },
    status: {
      type: String,
      validator: function validator(val) {
        return ['success', 'exception', 'warning'].indexOf(val) > -1;
      }
    },
    strokeWidth: {
      type: Number,
      default: 6
    },
    strokeLinecap: {
      type: String,
      default: 'round'
    },
    textInside: {
      type: Boolean,
      default: false
    },
    width: {
      type: Number,
      default: 126
    },
    showText: {
      type: Boolean,
      default: true
    },
    color: {
      type: [String, Array, Function],
      default: ''
    },
    format: Function
  },
  computed: {
    barStyle: function barStyle() {
      var style = {};
      style.width = this.percentage + '%';
      style.backgroundColor = this.getCurrentColor(this.percentage);
      return style;
    },
    relativeStrokeWidth: function relativeStrokeWidth() {
      return (this.strokeWidth / this.width * 100).toFixed(1);
    },
    radius: function radius() {
      if (this.type === 'circle' || this.type === 'dashboard') {
        return parseInt(50 - parseFloat(this.relativeStrokeWidth) / 2, 10);
      } else {
        return 0;
      }
    },
    trackPath: function trackPath() {
      var radius = this.radius;
      var isDashboard = this.type === 'dashboard';
      return '\n        M 50 50\n        m 0 ' + (isDashboard ? '' : '-') + radius + '\n        a ' + radius + ' ' + radius + ' 0 1 1 0 ' + (isDashboard ? '-' : '') + radius * 2 + '\n        a ' + radius + ' ' + radius + ' 0 1 1 0 ' + (isDashboard ? '' : '-') + radius * 2 + '\n        ';
    },
    perimeter: function perimeter() {
      return 2 * Math.PI * this.radius;
    },
    rate: function rate() {
      return this.type === 'dashboard' ? 0.75 : 1;
    },
    strokeDashoffset: function strokeDashoffset() {
      var offset = -1 * this.perimeter * (1 - this.rate) / 2;
      return offset + 'px';
    },
    trailPathStyle: function trailPathStyle() {
      return {
        strokeDasharray: this.perimeter * this.rate + 'px, ' + this.perimeter + 'px',
        strokeDashoffset: this.strokeDashoffset
      };
    },
    circlePathStyle: function circlePathStyle() {
      return {
        strokeDasharray: this.perimeter * this.rate * (this.percentage / 100) + 'px, ' + this.perimeter + 'px',
        strokeDashoffset: this.strokeDashoffset,
        transition: 'stroke-dasharray 0.6s ease 0s, stroke 0.6s ease'
      };
    },
    stroke: function stroke() {
      var ret = void 0;
      if (this.color) {
        ret = this.getCurrentColor(this.percentage);
      } else {
        switch (this.status) {
          case 'success':
            ret = '#13ce66';
            break;
          case 'exception':
            ret = '#ff4949';
            break;
          case 'warning':
            ret = '#e6a23c';
            break;
          default:
            ret = '#20a0ff';
        }
      }
      return ret;
    },
    iconClass: function iconClass() {
      if (this.status === 'warning') {
        return 'el-icon-warning';
      }
      if (this.type === 'line') {
        return this.status === 'success' ? 'el-icon-circle-check' : 'el-icon-circle-close';
      } else {
        return this.status === 'success' ? 'el-icon-check' : 'el-icon-close';
      }
    },
    progressTextSize: function progressTextSize() {
      return this.type === 'line' ? 12 + this.strokeWidth * 0.4 : this.width * 0.111111 + 2;
    },
    content: function content() {
      if (typeof this.format === 'function') {
        return this.format(this.percentage) || '';
      } else {
        return this.percentage + '%';
      }
    }
  },
  methods: {
    getCurrentColor: function getCurrentColor(percentage) {
      if (typeof this.color === 'function') {
        return this.color(percentage);
      } else if (typeof this.color === 'string') {
        return this.color;
      } else {
        return this.getLevelColor(percentage);
      }
    },
    getLevelColor: function getLevelColor(percentage) {
      var colorArray = this.getColorArray().sort(function (a, b) {
        return a.percentage - b.percentage;
      });

      for (var i = 0; i < colorArray.length; i++) {
        if (colorArray[i].percentage > percentage) {
          return colorArray[i].color;
        }
      }
      return colorArray[colorArray.length - 1].color;
    },
    getColorArray: function getColorArray() {
      var color = this.color;
      var span = 100 / color.length;
      return color.map(function (seriesColor, index) {
        if (typeof seriesColor === 'string') {
          return {
            color: seriesColor,
            percentage: (index + 1) * span
          };
        }
        return seriesColor;
      });
    }
  }
});
// CONCATENATED MODULE: ./packages/progress/src/progress.vue?vue&type=script&lang=js&
 /* harmony default export */ var src_progressvue_type_script_lang_js_ = (progressvue_type_script_lang_js_); 
// EXTERNAL MODULE: ./node_modules/vue-loader/lib/runtime/componentNormalizer.js
var componentNormalizer = __webpack_require__(0);

// CONCATENATED MODULE: ./packages/progress/src/progress.vue





/* normalize component */

var component = Object(componentNormalizer["a" /* default */])(
  src_progressvue_type_script_lang_js_,
  render,
  staticRenderFns,
  false,
  null,
  null,
  null
  
)

/* hot reload */
if (false) { var api; }
component.options.__file = "packages/progress/src/progress.vue"
/* harmony default export */ var progress = (component.exports);
// CONCATENATED MODULE: ./packages/progress/index.js


/* istanbul ignore next */
progress.install = function (Vue) {
  Vue.component(progress.name, progress);
};

/* harmony default export */ var packages_progress = __webpack_exports__["default"] = (progress);

/***/ }),
/* 64 */,
/* 65 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";
/* harmony import */ var packages_form_create_coreSrc_index__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(24);


var maker = {};

useAlias(maker);
useSelect(maker);
useTree(maker);
useUpload(maker);
useFrame(maker);

function useAlias(maker) {
  ['group', 'tree', 'switch', 'upload', 'autoComplete', 'checkbox', 'cascader', 'colorPicker', 'datePicker', 'frame', 'inputNumber', 'radio', 'rate'].forEach(function (name) {
    maker[name] = Object(packages_form_create_coreSrc_index__WEBPACK_IMPORTED_MODULE_0__[/* creatorFactory */ "a"])(name);
  });
  maker.auto = maker.autoComplete;
  maker.number = maker.inputNumber;
  maker.color = maker.colorPicker;
}

function useSelect(maker) {
  var _creatorFactory, _creatorFactory2;

  var select = 'select';
  var multiple = 'multiple';
  maker['selectMultiple'] = Object(packages_form_create_coreSrc_index__WEBPACK_IMPORTED_MODULE_0__[/* creatorFactory */ "a"])(select, (_creatorFactory = {}, _creatorFactory[multiple] = true, _creatorFactory));
  maker['selectOne'] = Object(packages_form_create_coreSrc_index__WEBPACK_IMPORTED_MODULE_0__[/* creatorFactory */ "a"])(select, (_creatorFactory2 = {}, _creatorFactory2[multiple] = false, _creatorFactory2));
}

function useTree(maker) {
  var name = 'tree';
  var types = { 'treeSelected': 'selected', 'treeChecked': 'checked' };

  Object.keys(types).reduce(function (m, key) {
    m[key] = Object(packages_form_create_coreSrc_index__WEBPACK_IMPORTED_MODULE_0__[/* creatorFactory */ "a"])(name, { type: types[key] });
    return m;
  }, maker);
}

function useUpload(maker) {
  var name = 'upload';
  var types = {
    image: ['image', 0],
    file: ['file', 0],
    uploadFileOne: ['file', 1],
    uploadImageOne: ['image', 1]
  };

  Object.keys(types).reduce(function (m, key) {
    m[key] = Object(packages_form_create_coreSrc_index__WEBPACK_IMPORTED_MODULE_0__[/* creatorFactory */ "a"])(name, function (m) {
      return m.props({ uploadType: types[key][0], maxLength: types[key][1] });
    });
    return m;
  }, maker);

  maker.uploadImage = maker.image;
  maker.uploadFile = maker.file;
}

function useFrame(maker) {
  var types = {
    frameInputs: ['input', 0],
    frameFiles: ['file', 0],
    frameImages: ['image', 0],
    frameInputOne: ['input', 1],
    frameFileOne: ['file', 1],
    frameImageOne: ['image', 1]
  };

  Object.keys(types).reduce(function (maker, key) {
    maker[key] = Object(packages_form_create_coreSrc_index__WEBPACK_IMPORTED_MODULE_0__[/* creatorFactory */ "a"])('frame', function (m) {
      return m.props({ type: types[key][0], maxLength: types[key][1] });
    });
    return maker;
  }, maker);

  maker.frameInput = maker.frameInputs;
  maker.frameFile = maker.frameFiles;
  maker.frameImage = maker.frameImages;
  return maker;
}

/* harmony default export */ __webpack_exports__["a"] = (maker);

/***/ }),
/* 66 */,
/* 67 */,
/* 68 */,
/* 69 */,
/* 70 */,
/* 71 */,
/* 72 */,
/* 73 */,
/* 74 */,
/* 75 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(process) {/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return elmFormCreate; });
/* harmony import */ var _components__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(78);
/* harmony import */ var _parsers__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(79);
/* harmony import */ var _alias__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(76);
/* harmony import */ var _manager__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(80);
/* harmony import */ var packages_form_create_coreSrc_index__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(24);
/* harmony import */ var _maker__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(65);
/* harmony import */ var _api__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(77);




// packages/form-create/src/index.js




function install(FormCreate) {
  FormCreate.componentAlias(_alias__WEBPACK_IMPORTED_MODULE_2__[/* default */ "a"]);
  _components__WEBPACK_IMPORTED_MODULE_0__[/* default */ "a"].forEach(function (component) {
    FormCreate.component(component.name, component);
  });

  _parsers__WEBPACK_IMPORTED_MODULE_1__[/* default */ "a"].forEach(function (parser) {
    FormCreate.parser(parser);
  });

  Object.keys(_maker__WEBPACK_IMPORTED_MODULE_5__[/* default */ "a"]).forEach(function (name) {
    FormCreate.maker[name] = _maker__WEBPACK_IMPORTED_MODULE_5__[/* default */ "a"][name];
  });
}

function elmFormCreate() {
  return Object(packages_form_create_coreSrc_index__WEBPACK_IMPORTED_MODULE_4__[/* default */ "b"])({
    ui: '' + process.env.UI,
    version: '' + process.env.VERSION,
    manager: _manager__WEBPACK_IMPORTED_MODULE_3__[/* default */ "a"],
    extendApi: _api__WEBPACK_IMPORTED_MODULE_6__[/* default */ "a"],
    install: install,
    attrs: {
      normal: ['col', 'wrap'],
      array: ['className'],
      key: ['title', 'info']
    }
  });
}
/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(84)))

/***/ }),
/* 76 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";
var PRE = 'el';
/* harmony default export */ __webpack_exports__["a"] = ({
  button: PRE + 'Button',
  icon: 'i',
  slider: PRE + 'Slider',
  rate: PRE + 'Rate',
  upload: 'fcUpload',
  cascader: PRE + 'Cascader',
  popover: PRE + 'Popover',
  tooltip: PRE + 'Tooltip',
  colorPicker: PRE + 'ColorPicker',
  timePicker: PRE + 'TimePicker',
  timeSelect: PRE + 'TimeSelect',
  datePicker: PRE + 'DatePicker',
  'switch': PRE + 'Switch',
  select: 'fcSelect',
  checkbox: 'fcCheckbox',
  radio: 'fcRadio',
  inputNumber: PRE + 'InputNumber',
  number: PRE + 'InputNumber',
  input: PRE + 'Input',
  formItem: PRE + 'FormItem',
  form: PRE + 'Form',
  frame: 'fcFrame',
  col: PRE + 'Col',
  row: PRE + 'Row',
  tree: 'fcTree',
  autoComplete: PRE + 'Autocomplete',
  auto: PRE + 'Autocomplete',
  group: 'fcGroup',
  object: 'fcSubForm',
  subForm: 'fcSubForm'
});

/***/ }),
/* 77 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return extendApi; });
/* harmony import */ var packages_form_create_utils_extend__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(7);
/* harmony import */ var packages_form_create_utils_type__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(5);
/* harmony import */ var packages_form_create_coreSrc_frame_util__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(10);
/* harmony import */ var packages_form_create_utils_toarray__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(32);






function tidyBtnProp(btn, def) {
  if (packages_form_create_utils_type__WEBPACK_IMPORTED_MODULE_1__[/* default */ "a"].Boolean(btn)) btn = { show: btn };else if (!packages_form_create_utils_type__WEBPACK_IMPORTED_MODULE_1__[/* default */ "a"].Undef(btn) && !packages_form_create_utils_type__WEBPACK_IMPORTED_MODULE_1__[/* default */ "a"].Object(btn)) btn = { show: def };
  return btn;
}

function extendApi(api, h) {
  Object(packages_form_create_utils_extend__WEBPACK_IMPORTED_MODULE_0__[/* default */ "a"])(api, {
    validate: function validate(callback) {
      var flag = void 0;
      var forms = api.children;
      var len = forms.length;
      var validate = function validate() {
        h.$manager.validate(function () {
          for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
            args[_key] = arguments[_key];
          }

          if (!args[0] || !flag) {
            flag = args;
          }
          callback.apply(undefined, flag);
        });
      };

      var validFn = function validFn(args) {
        setTimeout(function () {
          if (!args[0]) {
            if (!flag) {
              flag = args;
            }
          }
          if (! --len) {
            validate();
          }
        });
      };

      forms.forEach(function (form) {
        form.validate(function () {
          for (var _len2 = arguments.length, args = Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
            args[_key2] = arguments[_key2];
          }

          return validFn(args);
        });
      });

      if (!len) {
        validate();
      }
    },

    validateField: function validateField(field, callback) {
      if (!h.fieldCtx[field]) return;
      var sub = h.subForm[field];
      var len = 0;
      var flag = void 0;
      var validate = function validate() {
        h.$manager.validateField(field, function () {
          for (var _len3 = arguments.length, args = Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {
            args[_key3] = arguments[_key3];
          }

          if (args[0]) {
            flag = args;
          } else if (flag) {
            return callback('子表单验证未通过', flag[1]);
          }
          callback.apply(undefined, flag || args);
        });
      };
      var validFn = function validFn(args) {
        setTimeout(function () {
          if (!args[0]) {
            if (!flag) {
              flag = args;
            }
          }
          if (! --len) {
            validate();
          }
        });
      };
      sub && Object(packages_form_create_utils_toarray__WEBPACK_IMPORTED_MODULE_3__[/* default */ "a"])(sub).forEach(function (form) {
        len++;
        form.validate(function () {
          for (var _len4 = arguments.length, args = Array(_len4), _key4 = 0; _key4 < _len4; _key4++) {
            args[_key4] = arguments[_key4];
          }

          return validFn(args);
        });
      });

      if (!len) {
        validate();
      }
    },
    clearValidateState: function clearValidateState(fields) {
      var _this = this;

      var clearSub = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;

      api.helper.tidyFields(fields).forEach(function (field) {
        if (clearSub) _this.clearSubValidateState(field);
        var ctx = h.fieldCtx[field];
        if (!ctx) return;
        h.$manager.clearValidateState(ctx);
      });
    },
    clearSubValidateState: function clearSubValidateState(fields) {
      api.helper.tidyFields(fields).forEach(function (field) {
        var subForm = h.subForm[field];
        if (!subForm) return;
        if (Array.isArray(subForm)) {
          subForm.forEach(function (form) {
            form.clearValidateState();
          });
        } else if (subForm) {
          subForm.clearValidateState();
        }
      });
    },

    btn: {
      loading: function loading() {
        var _loading = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;

        api.submitBtnProps({ loading: !!_loading });
      },
      disabled: function disabled() {
        var _disabled = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;

        api.submitBtnProps({ disabled: !!_disabled });
      },
      show: function show() {
        var isShow = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;

        api.submitBtnProps({ show: !!isShow });
      }
    },
    resetBtn: {
      loading: function loading() {
        var _loading2 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;

        api.resetBtnProps({ loading: !!_loading2 });
      },
      disabled: function disabled() {
        var _disabled2 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;

        api.resetBtnProps({ disabled: !!_disabled2 });
      },
      show: function show() {
        var isShow = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;

        api.resetBtnProps({ show: !!isShow });
      }
    },
    submitBtnProps: function submitBtnProps() {
      var props = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};

      var btn = tidyBtnProp(h.options.submitBtn, true);
      Object(packages_form_create_utils_extend__WEBPACK_IMPORTED_MODULE_0__[/* default */ "a"])(btn, props);
      h.options.submitBtn = btn;
      api.refreshOptions();
    },
    resetBtnProps: function resetBtnProps() {
      var props = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};

      var btn = tidyBtnProp(h.options.resetBtn, false);
      Object(packages_form_create_utils_extend__WEBPACK_IMPORTED_MODULE_0__[/* default */ "a"])(btn, props);
      h.options.resetBtn = btn;
      api.refreshOptions();
    },
    submit: function submit(successFn, failFn) {
      var _this2 = this,
          _arguments = arguments;

      api.validate(function (valid) {
        if (valid) {
          var formData = api.formData();
          if (packages_form_create_utils_type__WEBPACK_IMPORTED_MODULE_1__[/* default */ "a"].Function(successFn)) Object(packages_form_create_coreSrc_frame_util__WEBPACK_IMPORTED_MODULE_2__[/* invoke */ "g"])(function () {
            return successFn(formData, _this2);
          });else {
            packages_form_create_utils_type__WEBPACK_IMPORTED_MODULE_1__[/* default */ "a"].Function(h.options.onSubmit) && Object(packages_form_create_coreSrc_frame_util__WEBPACK_IMPORTED_MODULE_2__[/* invoke */ "g"])(function () {
              return h.options.onSubmit(formData, _this2);
            });
            h.vm.$emit('submit', formData, _this2);
          }
        } else {
          packages_form_create_utils_type__WEBPACK_IMPORTED_MODULE_1__[/* default */ "a"].Function(failFn) && Object(packages_form_create_coreSrc_frame_util__WEBPACK_IMPORTED_MODULE_2__[/* invoke */ "g"])(function () {
            return failFn.apply(undefined, [_this2].concat(Array.prototype.slice.call(_arguments)));
          });
        }
      });
    }
  });

  return api;
}

/***/ }),
/* 78 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";

// EXTERNAL MODULE: external "babel-helper-vue-jsx-merge-props"
var external_babel_helper_vue_jsx_merge_props_ = __webpack_require__(22);
var external_babel_helper_vue_jsx_merge_props_default = /*#__PURE__*/__webpack_require__.n(external_babel_helper_vue_jsx_merge_props_);

// EXTERNAL MODULE: ./packages/form-create/utils/slot.js
var utils_slot = __webpack_require__(39);

// EXTERNAL MODULE: ./packages/checkbox-group/index.js + 5 modules
var checkbox_group = __webpack_require__(59);

// CONCATENATED MODULE: ./packages/form-create/src/components/checkbox.jsx


var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };

/* eslint-disable no-unused-vars */


var NAME = 'fcCheckbox';

/* harmony default export */ var components_checkbox = ({
  name: NAME,
  props: {
    formCreateRule: {
      type: Object,
      default: function _default() {
        return {};
      }
    },
    formCreateOptions: {
      type: Array,
      default: function _default() {
        return [];
      }
    },
    value: {
      type: Array,
      default: function _default() {
        return [];
      }
    },
    type: String
  },
  watch: {
    value: function value() {
      this.update();
    }
  },
  data: function data() {
    return {
      trueValue: []
    };
  },

  methods: {
    onInput: function onInput(n) {
      this.$emit('input', this.formCreateOptions.filter(function (opt) {
        return n.indexOf(opt.label) !== -1;
      }).map(function (opt) {
        return opt.value;
      }).filter(function (v) {
        return v !== undefined;
      }));
    },
    update: function update() {
      var _this = this;

      this.trueValue = this.value ? this.formCreateOptions.filter(function (opt) {
        return _this.value.indexOf(opt.value) !== -1;
      }).map(function (option) {
        return option.label;
      }) : [];
    }
  },
  created: function created() {
    this.update();
  },
  render: function render() {
    var _this2 = this;

    var h = arguments[0];

    return h(
      checkbox_group["default"],
      external_babel_helper_vue_jsx_merge_props_default()([this.formCreateRule, {
        attrs: {
          value: this.trueValue
        },
        on: {
          'input': this.onInput
        }
      }]),
      [this.formCreateOptions.map(function (opt, index) {
        var props = _extends({}, opt);
        var Type = _this2.type === 'button' ? 'ElCheckboxButton' : 'ElCheckbox';
        delete props.value;
        return h(Type, external_babel_helper_vue_jsx_merge_props_default()([{ props: props }, { key: Type + index + opt.value }]));
      }), Object(utils_slot["a" /* default */])(this.$slots)]
    );
  }
});
// EXTERNAL MODULE: ./packages/form-create/utils/toarray.js
var toarray = __webpack_require__(32);

// CONCATENATED MODULE: ./packages/form-create/src/components/frame.jsx
var frame_extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };


var frame_NAME = 'fcFrame';

/* harmony default export */ var components_frame = ({
  name: frame_NAME,
  props: {
    formCreateField: String,
    type: {
      type: String,
      default: 'input'
    },
    field: String,
    helper: {
      type: Boolean,
      default: true
    },
    disabled: {
      type: Boolean,
      default: false
    },
    src: {
      type: String,
      required: true
    },
    icon: {
      type: String,
      default: 'el-icon-upload2'
    },
    width: {
      type: String,
      default: '500px'
    },
    height: {
      type: String,
      default: '370px'
    },
    maxLength: {
      type: Number,
      default: 0
    },
    okBtnText: {
      type: String,
      default: '确定'
    },
    closeBtnText: {
      type: String,
      default: '关闭'
    },
    modalTitle: String,
    handleIcon: {
      type: [String, Boolean],
      default: undefined
    },
    title: String,
    allowRemove: {
      type: Boolean,
      default: true
    },
    onOpen: {
      type: Function,
      default: function _default() {}
    },
    onOk: {
      type: Function,
      default: function _default() {}
    },
    onCancel: {
      type: Function,
      default: function _default() {}
    },
    onLoad: {
      type: Function,
      default: function _default() {}
    },
    onBeforeRemove: {
      type: Function,
      default: function _default() {}
    },
    onRemove: {
      type: Function,
      default: function _default() {}
    },
    onHandle: {
      type: Function,
      default: function _default(src) {
        this.previewImage = this.getSrc(src);
        this.previewVisible = true;
      }
    },
    modal: {
      type: Object,
      default: function _default() {
        return {};
      }
    },
    srcKey: {
      type: [String, Number]
    },
    value: [Array, String, Number, Object],
    previewMask: undefined,
    footer: {
      type: Boolean,
      default: true
    },
    reload: {
      type: Boolean,
      default: true
    },
    closeBtn: {
      type: Boolean,
      default: true
    },
    okBtn: {
      type: Boolean,
      default: true
    }

  },
  data: function data() {
    return {
      fileList: Object(toarray["a" /* default */])(this.value),
      previewVisible: false,
      frameVisible: false,
      previewImage: ''
    };
  },

  watch: {
    value: function value(n) {
      this.fileList = Object(toarray["a" /* default */])(n);
    },
    fileList: function fileList(n) {
      var val = this.maxLength === 1 ? n[0] || '' : n;
      this.$emit('input', val);
      this.$emit('change', val);
    },
    src: function src(n) {
      this.modalVm && (this.modalVm.src = n);
    }
  },
  methods: {
    key: function key(unique) {
      return unique;
    },
    closeModel: function closeModel(close) {
      this.$emit(close ? '$close' : '$ok');
      if (this.reload) {
        this.$off('$ok');
        this.$off('$close');
      }
      this.frameVisible = false;
    },
    handleCancel: function handleCancel() {
      this.previewVisible = false;
    },
    showModel: function showModel() {
      if (this.disabled || this.onOpen() === false) {
        return;
      }
      this.frameVisible = true;
    },
    makeInput: function makeInput() {
      var _this = this;

      var h = this.$createElement;

      var props = {
        type: 'text',
        value: this.fileList.map(function (v) {
          return _this.getSrc(v);
        }).toString(),
        readonly: true
      };

      return h(
        ElInput,
        {
          attrs: { props: props },
          key: this.key('input') },
        [this.fileList.length ? h('i', { slot: 'suffix', 'class': 'el-input__icon el-icon-circle-close'
          // eslint-disable-next-line no-return-assign
          , on: {
            'click': function click() {
              return _this.fileList = [];
            }
          }
        }) : null, h(ElButton, {
          attrs: { icon: this.icon, on: { 'click': function click() {
                return _this.showModel();
              } } },
          slot: 'append' })]
      );
    },
    makeGroup: function makeGroup(children) {
      var h = this.$createElement;

      if (!this.maxLength || this.fileList.length < this.maxLength) {
        children.push(this.makeBtn());
      }
      return h(
        'div',
        { key: this.key('group') },
        [frame_extends({}, children)]
      );
    },
    makeItem: function makeItem(index, children) {
      var h = this.$createElement;

      return h(
        'div',
        { 'class': 'fc-files', key: this.key('file' + index) },
        [frame_extends({}, children)]
      );
    },
    valid: function valid(f) {
      var field = this.formCreateField || this.field;
      if (field && f !== field) {
        throw new Error('[frame]无效的字段值');
      }
    },
    makeIcons: function makeIcons(val, index) {
      var h = this.$createElement;

      if (this.handleIcon !== false || this.allowRemove === true) {
        var icons = [];
        if (this.type !== 'file' && this.handleIcon !== false || this.type === 'file' && this.handleIcon) {
          icons.push(this.makeHandleIcon(val, index));
        }
        if (this.allowRemove) {
          icons.push(this.makeRemoveIcon(val, index));
        }
        return h(
          'div',
          { 'class': 'fc-upload-cover', key: this.key('uc') },
          [icons]
        );
      }
    },
    makeHandleIcon: function makeHandleIcon(val, index) {
      var _this2 = this;

      var h = this.$createElement;

      return h('i', {
        'class': this.handleIcon === true || this.handleIcon === undefined ? 'el-icon-view' : this.handleIcon,
        on: {
          'click': function click() {
            return _this2.handleClick(val);
          }
        },
        key: this.key('hi' + index) });
    },
    makeRemoveIcon: function makeRemoveIcon(val, index) {
      var _this3 = this;

      var h = this.$createElement;

      return h('i', { 'class': 'el-icon-delete', on: {
          'click': function click() {
            return _this3.handleRemove(val);
          }
        },
        key: this.key('ri' + index) });
    },
    makeFiles: function makeFiles() {
      var _this4 = this;

      var h = this.$createElement;

      return this.makeGroup(this.fileList.map(function (src, index) {
        return _this4.makeItem(index, [h('i', { 'class': 'el-icon-tickets',
          on: {
            'click': function click() {
              return _this4.handleClick(src);
            }
          }
        }), _this4.makeIcons(src, index)]);
      }));
    },
    makeImages: function makeImages() {
      var _this5 = this;

      var h = this.$createElement;

      return this.makeGroup(this.fileList.map(function (src, index) {
        return _this5.makeItem(index, [h('img', {
          attrs: { src: _this5.getSrc(src) }
        }), _this5.makeIcons(src, index)]);
      }));
    },
    makeBtn: function makeBtn() {
      var _this6 = this;

      var h = this.$createElement;

      return h(
        'div',
        { 'class': 'fc-upload-btn', on: {
            'click': function click() {
              return _this6.showModel();
            }
          },
          key: this.key('btn') },
        [h('i', { 'class': this.icon })]
      );
    },
    handleClick: function handleClick(src) {
      if (this.disabled) {
        return;
      }
      return this.onHandle(src);
    },
    handleRemove: function handleRemove(src) {
      if (this.disabled) {
        return;
      }
      if (this.onBeforeRemove(src) !== false) {
        this.fileList.splice(this.fileList.indexOf(src), 1);
        this.onRemove(src);
      }
    },
    getSrc: function getSrc(src) {
      return !this.srcKey ? src : src[this.srcKey];
    },
    frameLoad: function frameLoad(iframe) {
      var _this7 = this;

      this.onLoad(iframe);
      try {
        if (this.helper === true) {
          iframe['form_create_helper'] = {
            close: function close(field) {
              _this7.valid(field);
              _this7.closeModel();
            },
            set: function set(field, value) {
              _this7.valid(field);
              if (!_this7.disabled) {
                _this7.$emit('input', value);
              }
            },
            get: function get(field) {
              _this7.valid(field);
              return _this7.value;
            },
            onOk: function onOk(fn) {
              return _this7.$on('$ok', fn);
            },
            onClose: function onClose(fn) {
              return _this7.$on('$close', fn);
            }
          };
        }
      } catch (e) {
        console.log(e);
      }
    },
    makeFooter: function makeFooter() {
      var _this8 = this;

      var h = this.$createElement;
      var _$props = this.$props,
          okBtnText = _$props.okBtnText,
          closeBtnText = _$props.closeBtnText,
          closeBtn = _$props.closeBtn,
          okBtn = _$props.okBtn,
          footer = _$props.footer;


      if (!footer) {
        return;
      }
      return h(
        'div',
        { slot: 'footer' },
        [closeBtn ? h(
          ElButton,
          {
            on: {
              'click': function click() {
                return _this8.onCancel() !== false && (_this8.frameVisible = false);
              }
            }
          },
          [closeBtnText]
        ) : null, okBtn ? h(
          ElButton,
          {
            attrs: { type: 'primary'
            },
            on: {
              'click': function click() {
                return _this8.onOk() !== false && _this8.closeModel();
              }
            }
          },
          [okBtnText]
        ) : null]
      );
    }
  },
  render: function render() {
    var _this9 = this;

    var h = arguments[0];

    var type = this.type;

    var node = void 0;
    if (type === 'input') {
      node = this.makeInput();
    } else if (type === 'image') {
      node = this.makeImages();
    } else {
      node = this.makeFiles();
    }

    var _$props2 = this.$props,
        _$props2$width = _$props2.width,
        width = _$props2$width === undefined ? '30%' : _$props2$width,
        height = _$props2.height,
        src = _$props2.src,
        title = _$props2.title,
        modalTitle = _$props2.modalTitle;

    this.$nextTick(function () {
      if (_this9.$refs.frame) {
        _this9.frameLoad(_this9.$refs.frame.contentWindow || {});
      }
    });
    return h(
      'div',
      { 'class': '_fc-frame' },
      [node, h(
        'el-dialog',
        {
          attrs: { appendToBody: true, modal: this.previewMask, title: modalTitle, visible: this.previewVisible
          },
          on: {
            'close': this.handleCancel
          }
        },
        [h('img', {
          attrs: { alt: 'example', src: this.previewImage },
          style: 'width: 100%' })]
      ), h(
        'el-dialog',
        {
          attrs: { appendToBody: true, props: frame_extends({ width: width, title: title }, this.modal), visible: this.frameVisible
          },
          on: {
            'close': function close() {
              return _this9.closeModel(true);
            }
          }
        },
        [this.frameVisible || !this.reload ? h('iframe', { ref: 'frame', attrs: { src: src, frameBorder: '0' },
          style: {
            'height': height,
            'border': '0 none',
            'width': '100%'
          } }) : null, this.makeFooter()]
      )]
    );
  },
  mounted: function mounted() {
    this.$on('fc.closeModal', this.closeModal);
  }
});
// EXTERNAL MODULE: ./packages/radio-group/index.js + 5 modules
var radio_group = __webpack_require__(58);

// CONCATENATED MODULE: ./packages/form-create/src/components/radio.jsx


var radio_extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };

/* eslint-disable no-unused-vars */



var radio_NAME = 'fcRadio';

/* harmony default export */ var components_radio = ({
  name: radio_NAME,
  props: {
    formCreateRule: {
      type: Object,
      default: function _default() {
        return {};
      }
    },
    formCreateOptions: {
      type: Array,
      default: function _default() {
        return [];
      }
    },
    value: {},
    type: String
  },
  watch: {
    value: function value() {
      this.update();
    }
  },
  data: function data() {
    return {
      trueValue: []
    };
  },

  methods: {
    onInput: function onInput(n) {
      this.$emit('input', this.formCreateOptions.filter(function (opt) {
        return opt.label === n;
      }).reduce(function (initial, opt) {
        return opt.value;
      }, ''));
    },
    update: function update() {
      var _this = this;

      this.trueValue = this.formCreateOptions.filter(function (opt) {
        return opt.value === _this.value;
      }).reduce(function (initial, opt) {
        return opt.label;
      }, '');
    }
  },
  created: function created() {
    this.update();
  },
  render: function render() {
    var _this2 = this;

    var h = arguments[0];

    return h(
      radio_group["default"],
      external_babel_helper_vue_jsx_merge_props_default()([this.formCreateRule, {
        attrs: { value: this.trueValue
        },
        on: {
          'input': this.onInput
        }
      }]),
      [this.formCreateOptions.map(function (opt, index) {
        var props = radio_extends({}, opt);
        var Type = _this2.type === 'button' ? 'ElRadioButton' : 'ElRadio';
        delete props.value;
        return h(Type, external_babel_helper_vue_jsx_merge_props_default()([{ props: props }, { key: Type + index + opt.value }]));
      }), Object(utils_slot["a" /* default */])(this.$slots)]
    );
  }
});
// EXTERNAL MODULE: ./packages/form-create/utils/type.js
var utils_type = __webpack_require__(5);

// EXTERNAL MODULE: ./packages/select/src/select.vue + 10 modules
var src_select = __webpack_require__(43);

// EXTERNAL MODULE: ./packages/select/src/option.vue + 4 modules
var src_option = __webpack_require__(33);

// CONCATENATED MODULE: ./packages/form-create/src/components/select.jsx

// eslint-disable-next-line no-unused-vars



var select_NAME = 'fcSelect';
/* harmony default export */ var components_select = ({
  name: select_NAME,
  functional: true,
  components: {
    ElSelect: src_select["a" /* default */],
    ElOption: src_option["a" /* default */]
  },
  props: {
    formCreateOptions: {
      type: Array,
      default: function _default() {
        return [];
      }
    }
  },
  render: function render(h, ctx) {
    function setLabelOrValue(key, showKey) {
      if (key) {
        return key;
      } else {
        return showKey;
      }
    }
    var select = h(
      src_select["a" /* default */],
      ctx.data,
      [ctx.props.formCreateOptions.map(function (props, index) {
        var slot = props.slot;
        return h(
          src_option["a" /* default */],
          {
            attrs: {
              label: props[setLabelOrValue(ctx.data.props.label, 'label')],
              value: props[setLabelOrValue(ctx.data.props.showValue, 'value')],
              disabled: props.disabled
            },
            key: '' + index * Math.ceil(Math.random() * 1000 * Math.ceil(Math.random() * 1000)) },
          [slot ? h(
            'template',
            {
              slot: props.slotName || 'default' },
            [utils_type["a" /* default */].Function(slot) ? props.slot(h) : slot]
          ) : null]
        );
      }), ctx.children]
    );
    return h('div', [select]);
  }
});
// EXTERNAL MODULE: ./packages/tree/index.js + 13 modules
var tree = __webpack_require__(57);

// CONCATENATED MODULE: ./packages/form-create/src/components/tree.jsx

/* eslint-disable no-unused-vars */



var tree_NAME = 'fcTree';

/* harmony default export */ var components_tree = ({
  name: tree_NAME,
  formCreateParser: {
    mergeProp: function mergeProp(ctx) {
      var props = ctx.prop.props;
      if (!props.nodeKey) props.nodeKey = 'id';
      if (!props.props) {
        props.props = {
          label: 'title'
        };
      }
    }
  },
  props: {
    formCreateRule: {
      type: Object,
      default: function _default() {
        return { props: {} };
      }
    },
    type: {
      type: String,
      default: 'checked'
    },
    value: {
      type: [Array, String, Number],
      default: function _default() {
        return [];
      }
    }
  },
  watch: {
    value: function value() {
      this.setValue();
    }
  },
  methods: {
    onChange: function onChange() {
      this.updateValue();
    },
    updateValue: function updateValue() {
      if (!this.$refs.tree) return;
      var type = this.type.toLocaleLowerCase();
      var value = void 0;

      if (type === 'selected') {
        value = this.$refs.tree.getCurrentKey();
      } else {
        value = this.$refs.tree.getCheckedKeys();
      }

      this.$emit('input', value);
    },
    setValue: function setValue() {
      var type = this.type.toLocaleLowerCase();

      if (type === 'selected') {
        this.$refs.tree.setCurrentKey(this.value);
      } else {
        this.$refs.tree.setCheckedKeys(Object(toarray["a" /* default */])(this.value));
      }
    }
  },
  render: function render() {
    var _this = this;

    var h = arguments[0];

    return h(
      tree["default"],
      external_babel_helper_vue_jsx_merge_props_default()([this.formCreateRule, { ref: 'tree', on: {
          'check-change': function checkChange() {
            return _this.updateValue();
          },
          'node-click': function nodeClick() {
            return _this.updateValue();
          }
        }
      }]),
      [Object(utils_slot["a" /* default */])(this.$slots)]
    );
  },
  mounted: function mounted() {
    this.setValue();
    this.updateValue();
  }
});
// EXTERNAL MODULE: ./packages/upload/index.js + 17 modules
var upload = __webpack_require__(56);

// EXTERNAL MODULE: ./packages/progress/index.js + 5 modules
var progress = __webpack_require__(63);

// CONCATENATED MODULE: ./packages/form-create/src/components/upload.jsx


var upload_extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };

/* eslint-disable no-unused-vars */


// import './style.css';

// packages\progress\src\progress.vue


function parseFile(file, i) {
  return {
    url: file,
    name: getFileName(file),
    uid: i
  };
}

function getFileName(file) {
  return ('' + file).split('/').pop();
}

var upload_NAME = 'fcUpload';

/* harmony default export */ var components_upload = ({
  name: upload_NAME,
  props: {
    formCreateRule: {
      type: Object,
      default: function _default() {
        return { props: {} };
      }
    },
    onHandle: {
      type: Function,
      default: function _default(file) {
        this.previewImage = file.url;
        this.previewVisible = true;
      }
    },
    uploadType: {
      type: String,
      default: 'file'
    },
    limit: {
      type: Number,
      default: 0
    },
    allowRemove: {
      type: Boolean,
      default: true
    },
    previewMask: undefined,
    modalTitle: String,
    handleIcon: {
      type: [String, Boolean],
      default: function _default() {
        return undefined;
      }
    },
    value: [Array, String]
  },
  data: function data() {
    return {
      uploadModel: [1111111]
    };
  },
  created: function created() {
    // if (this.formCreateRule.props.showFileList === undefined) {
    //   this.formCreateRule.props.showFileList = false;
    // }
    // this.formCreateRule.props.fileList = toArray(this.value).map(parseFile);
  },

  watch: {
    uploadModel: function uploadModel(newV) {
      console.log(newV);
    }
    // limit(n, o) {
    //   if (o === 1 || n === 1) {
    //     this.update();
    //   }
    // }

  },
  methods: {
    key: function key(unique) {
      return unique;
    },

    // isDisabled() {
    //   return this.formCreateRule.props.disabled === true;
    // },
    // onRemove(file) {
    //   if (this.isDisabled()) {
    //     return;
    //   }
    //   this.$refs.upload.handleRemove(file);
    // },
    // handleClick(file) {
    //   if (this.isDisabled()) {
    //     return;
    //   }
    //   this.onHandle(file);
    // },
    // makeItem(file, index) {
    //   return this.uploadType === 'image'
    //     ? <img src={file.url} key={this.key('img' + index)}/>
    //     : <i class="el-icon-tickets" key={this.key('i' + index)}/>;
    // },
    // makeRemoveIcon(file, index) {
    //   return <i class="el-icon-delete" on-click={() => this.onRemove(file)} key={this.key('ri' + index)}/>;
    // },
    // makeHandleIcon(file, index) {
    //   return <i
    //     class={(this.handleIcon === true || this.handleIcon === undefined) ? 'el-icon-view' : this.handleIcon}
    //     on-click={() => this.handleClick(file)} key={this.key('hi' + index)}/>;
    // },
    // makeProgress(file, index) {
    //   return <ElProgress props={{percentage: file.percentage, type: 'circle', width: 52}} style="margin-top:2px;"
    //     key={this.key('pg' + index)}/>;
    // },
    // makeIcons(file, index) {
    //   const icons = [];
    //   if (this.allowRemove || this.handleIcon !== false) {
    //     if ((this.uploadType !== 'file' && this.handleIcon !== false) || (this.uploadType === 'file' && this.handleIcon)) {
    //       icons.push(this.makeHandleIcon(file, index));
    //     }
    //     if (this.allowRemove) {
    //       icons.push(this.makeRemoveIcon(file, index));
    //     }

    //     return <div class='fc-upload-cover'>{icons}</div>;
    //   }
    // },
    // makeFiles() {
    //   return this.uploadList.map((file, index) => this.$scopedSlots.fileList ? this.$scopedSlots.fileList({
    //     file,
    //     index,
    //     vm: this
    //   }) : <div key={this.key(index)}
    //     class='fc-files'>{(file.percentage !== undefined && file.status !== 'success') ? this.makeProgress(file, index) : [this.makeItem(file, index), this.makeIcons(file, index)]}</div>);
    // },
    // makeUpload() {
    //   const isShow = (!this.limit || this.limit > this.uploadList.length);
    //   return <ElUpload {...this.formCreateRule} ref="upload"
    //     styleObj={{display: 'inline-block', width: '80px'}}
    //     key={this.key('upload')}>
    //     {isShow ? <template slot="default">
    //       {this.$slots.default || <div class='fc-upload-btn'>
    //         <i class="el-icon-upload2"/>
    //       </div>}
    //     </template> : null}{getSlot(this.$slots, ['default'])}
    //   </ElUpload>;
    // }
    // update() {
    //   let files = this.$refs.upload.uploadFiles.map((file) => file.url).filter((url) => url !== undefined);
    //   this.$emit('input', this.limit === 1 ? (files[0] || '') : files);
    // },
    // handleCancel() {
    //   this.previewVisible = false;
    // }
    uploadChange: function uploadChange(file, fileList) {
      this.$emit('input', fileList);
    }
  },
  mounted: function mounted() {
    // this.uploadList = this.$refs.upload.uploadFiles;
    // this.$watch(() => this.$refs.upload.uploadFiles, () => {
    //   this.update();
    // }, {deep: true});
  },
  render: function render(h) {
    // if (this.$refs.upload) {
    //   if (this.formCreateRule.props.showFileList === undefined) {
    //     this.formCreateRule.props.showFileList = this.$refs.upload.showFileList;
    //   }
    //   this.formCreateRule.props.fileList = this.$refs.upload.fileList;
    // }
    /**
     * <div
        class='_fc-upload'>{[this.formCreateRule.props.showFileList ? [] : this.makeFiles(), this.makeUpload()]}
        <el-dialog appendToBody={true} modal={this.previewMask} title={this.modalTitle} visible={this.previewVisible}
          on-close={this.handleCancel}>
          <img alt="example" style="width: 100%" src={this.previewImage}/>
        </el-dialog>
      </div>
       scopedSlots: {
    default: props => createElement('span', props.text)
     {componentsVue}
    },{getSlot(this.$slots, ['default'])}
    */
    // const isShow = (!this.limit || this.limit > this.uploadList.length);
    var componentsVue = null;
    if (this.formCreateRule.components) {
      componentsVue = h(this.formCreateRule.components, { props: upload_extends({}, this.formCreateRule.componentsProp) }, this.formCreateRule.componentsProp.text);
    }
    return h(
      'div',
      { 'class': 'fc_upload' },
      [h(
        upload["default"],
        external_babel_helper_vue_jsx_merge_props_default()([{ ref: 'upload',
          key: this.key('upload'),
          on: {
            'onChange': this.uploadChange
          }
        }, this.formCreateRule]),
        [componentsVue ? componentsVue : h(
          'template',
          { slot: 'default' },
          [this.$slots.default || h(
            'div',
            { 'class': 'fc-upload-btn' },
            [h('i', { 'class': this.formCreateRule.icon ? this.formCreateRule.icon : 'el-icon-upload2' })]
          )]
        )]
      )]
    );
  }
});
// EXTERNAL MODULE: ./packages/col/index.js + 1 modules
var col = __webpack_require__(55);

// EXTERNAL MODULE: ./packages/row/index.js + 1 modules
var row = __webpack_require__(60);

// CONCATENATED MODULE: ./packages/form-create/src/components/group.jsx
var group_extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };

/* eslint-disable no-unused-vars */



var group_NAME = 'fcGroup';

/* harmony default export */ var group = ({
  name: group_NAME,
  props: {
    field: String,
    rule: [Array, Object],
    rules: Array,
    expand: Number,
    options: Object,
    formCreate: Object,
    button: {
      type: Boolean,
      default: true
    },
    max: {
      type: Number,
      default: 0
    },
    min: {
      type: Number,
      default: 0
    },
    value: {
      type: Array,
      default: function _default() {
        return [];
      }
    },
    disabled: {
      type: Boolean,
      default: false
    },
    fontSize: {
      type: Number,
      default: 28
    },
    onBeforeRemove: {
      type: Function,
      default: function _default() {}
    },
    onBeforeAdd: {
      type: Function,
      default: function _default() {}
    }
  },
  data: function data() {
    return {
      len: 0,
      cacheRule: {},
      cacheValue: {}
    };
  },

  computed: {
    formRule: function formRule() {
      if (this.rule) {
        return Array.isArray(this.rule) ? this.rule : [this.rule];
      }
      if (this.rules) {
        return this.rules;
      }
      return [];
    }
  },
  watch: {
    disabled: function disabled(n) {
      var lst = this.cacheRule;
      Object.keys(lst).forEach(function (k) {
        lst[k].$f.disabled(n);
      });
    },
    expand: function expand(n) {
      var d = n - this.value.length;
      if (d > 0) {
        this.expandRule(d);
      }
    },
    value: function value(n) {
      var _this = this;

      n = n || [];
      // eslint-disable-next-line one-var
      var keys = Object.keys(this.cacheRule),
          total = keys.length,
          len = total - n.length;
      if (len < 0) {
        for (var i = len; i < 0; i++) {
          this.addRule(n.length + i);
        }
        for (var _i = 0; _i < total; _i++) {
          this.setValue(keys[_i], n[_i]);
        }
      } else {
        if (len > 0) {
          for (var _i2 = 0; _i2 < len; _i2++) {
            this.removeRule(keys[total - _i2 - 1]);
          }
          this.subForm();
        }
        n.forEach(function (val, i) {
          _this.setValue(keys[i], n[i]);
        });
      }
    }
  },
  methods: {
    _value: function _value(v) {
      return v && Object(utils_type["b" /* hasProperty */])(v, this.field) ? v[this.field] : v;
    },
    cache: function cache(k, val) {
      this.cacheValue[k] = JSON.stringify(val);
    },
    input: function input(value) {
      this.$emit('input', value);
      this.$emit('change', value);
    },
    formData: function formData(key, _formData) {
      var _this2 = this;

      var cacheRule = this.cacheRule;
      var keys = Object.keys(cacheRule);
      if (keys.filter(function (k) {
        return cacheRule[k].$f;
      }).length !== keys.length) {
        return;
      }
      var value = keys.map(function (k) {
        var data = key === k ? _formData : group_extends({}, _this2.cacheRule[k].$f.form);
        var value = _this2.field ? data[_this2.field] || null : data;
        _this2.cache(k, value);
        return value;
      });
      this.input(value);
    },
    setValue: function setValue(key, value) {
      // eslint-disable-next-line one-var
      var field = this.field,
          $f = this.cacheRule[key].$f;
      if (field) {
        var _value2;

        value = (_value2 = {}, _value2[field] = this._value(value), _value2);
      }
      if (this.cacheValue[key] === JSON.stringify(field ? value[field] : value)) {
        return;
      }
      this.cache(key, value);
      $f.coverValue(value || {});
    },
    addRule: function addRule(i, emit) {
      var _ref,
          _this3 = this;

      var rule = this.$formCreate.copyRules(this.formRule);
      var options = this.options ? group_extends({}, this.options) : {
        submitBtn: false,
        resetBtn: false
      };
      options.formData = this.field ? (_ref = {}, _ref[this.field] = this._value(this.value[i]), _ref) : this.value[i] || {};
      this.$set(this.cacheRule, ++this.len, { rule: rule, options: options });
      if (emit) {
        this.$nextTick(function () {
          return _this3.$emit('add', rule, Object.keys(_this3.cacheRule).length - 1);
        });
      }
    },
    add$f: function add$f(i, key, $f) {
      var _this4 = this;

      this.cacheRule[key].$f = $f;
      this.subForm();
      this.$nextTick(function () {
        $f.disabled(_this4.disabled);
        _this4.$emit('itemMounted', $f, Object.keys(_this4.cacheRule).indexOf(key));
      });
    },
    subForm: function subForm() {
      var _this5 = this;

      this.$emit('fc.sub-form', Object.keys(this.cacheRule).map(function (k) {
        return _this5.cacheRule[k].$f;
      }));
    },
    removeRule: function removeRule(key, emit) {
      var _this6 = this;

      var index = Object.keys(this.cacheRule).indexOf(key);
      this.$delete(this.cacheRule, key);
      this.$delete(this.cacheValue, key);
      if (emit) {
        this.$nextTick(function () {
          return _this6.$emit('remove', index);
        });
      }
    },
    add: function add(i) {
      if (this.disabled || this.onBeforeAdd(this.value) === false) {
        return;
      }
      this.addRule(i, true);
    },
    del: function del(index, key) {
      if (this.disabled || this.onBeforeRemove(this.value) === false) {
        return;
      }
      this.removeRule(key, true);
      this.subForm();
      this.value.splice(index, 1);
      this.input(this.value);
    },
    addIcon: function addIcon(key) {
      var h = this.$createElement;

      return h('i', { key: 'a' + key, 'class': 'el-icon-circle-plus-outline',
        style: 'font-size:' + this.fontSize + 'px;cursor:' + (this.disabled ? 'not-allowed;color:#c9cdd4' : 'pointer') + ';',
        on: {
          'click': this.add
        }
      });
    },
    delIcon: function delIcon(index, key) {
      var _this7 = this;

      var h = this.$createElement;

      return h('i', { key: 'd' + key, 'class': 'el-icon-remove-outline',
        style: 'font-size:' + this.fontSize + 'px;cursor:' + (this.disabled ? 'not-allowed;color:#c9cdd4' : 'pointer;color:#606266') + ';',
        on: {
          'click': function click() {
            return _this7.del(index, key);
          }
        }
      });
    },
    makeIcon: function makeIcon(total, index, key) {
      var _this8 = this;

      if (this.$scopedSlots.button) {
        return this.$scopedSlots.button({
          total: total,
          index: index,
          vm: this,
          key: key,
          del: function del() {
            return _this8.del(index, key);
          },
          add: this.add
        });
      }
      if (index === 0) {
        return [this.max !== 0 && total >= this.max ? null : this.addIcon(key), this.min === 0 || total > this.min ? this.delIcon(index, key) : null];
      }
      if (index >= this.min) {
        return this.delIcon(index, key);
      }
    },
    emitEvent: function emitEvent(name, args, index, key) {
      this.$emit.apply(this, [name].concat(args, [this.cacheRule[key].$f, index]));
    },
    expandRule: function expandRule(n) {
      for (var i = 0; i < n; i++) {
        this.value.push(this.field ? null : {});
      }
    }
  },
  created: function created() {
    var d = (this.expand || 0) - this.value.length;
    if (d > 0) {
      this.expandRule(d);
    }
    for (var i = 0; i < this.value.length; i++) {
      this.addRule(i);
    }
  },
  render: function render() {
    var _this9 = this;

    var h = arguments[0];

    var keys = Object.keys(this.cacheRule);
    var button = this.button;
    return keys.length === 0 ? this.$scopedSlots.default ? this.$scopedSlots.default({
      vm: this,
      add: this.add
    }) : h('i', { key: 'a_def', 'class': 'el-icon-circle-plus-outline',
      style: 'font-size:' + this.fontSize + 'px;vertical-align:middle;color:' + (this.disabled ? '#c9cdd4;cursor: not-allowed' : '#606266;cursor:pointer') + ';',
      on: {
        'click': this.add
      }
    }) : h(
      'div',
      { key: 'con' },
      [keys.map(function (key, index) {
        var _cacheRule$key = _this9.cacheRule[key],
            rule = _cacheRule$key.rule,
            options = _cacheRule$key.options;

        return h(
          row["default"],
          {
            attrs: { align: 'middle', type: 'flex' },
            key: key,
            style: 'border-bottom:1px dashed #DCDFE6;margin-bottom:10px;' },
          [h(
            col["default"],
            {
              attrs: { span: button ? 20 : 24 }
            },
            [h(ElFormItem, [h(FormCreate, {
              key: key,
              attrs: { on: {
                  'update:value': function updateValue(formData) {
                    return _this9.formData(key, formData);
                  },
                  'emit-event': function emitEvent(name) {
                    for (var _len = arguments.length, args = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
                      args[_key - 1] = arguments[_key];
                    }

                    return _this9.emitEvent(name, args, index, key);
                  },
                  input: function input($f) {
                    return _this9.add$f(index, key, $f);
                  }
                },
                rule: rule,
                option: options, extendOption: true }
            })])]
          ), button ? h(
            col["default"],
            {
              attrs: { span: 2, pull: 1, push: 1 }
            },
            [_this9.makeIcon(keys.length, index, key)]
          ) : null]
        );
      })]
    );
  }
});
// CONCATENATED MODULE: ./packages/form-create/src/components/subForm.jsx
var subForm_extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };

var subForm_NAME = 'fcSubForm';

/* harmony default export */ var subForm = ({
  name: subForm_NAME,
  props: {
    rule: Array,
    options: Object,
    formCreate: Object,
    value: {
      type: Object,
      default: function _default() {
        return {};
      }
    },
    disabled: {
      type: Boolean,
      default: false
    }
  },
  data: function data() {
    return {
      cacheRule: {},
      cacheValue: {}
    };
  },

  watch: {
    disabled: function disabled(n) {
      this.cacheRule.$f.disabled(n);
    },
    value: function value(n) {
      this.setValue(n);
    }
  },
  methods: {
    formData: function formData(value) {
      this.cacheValue = JSON.stringify(value);
      this.$emit('input', value);
      this.$emit('change', value);
    },
    setValue: function setValue(value) {
      var str = JSON.stringify(value);
      if (this.cacheValue === str) {
        return;
      }
      this.cacheValue = str;
      this.cacheRule.$f.coverValue(value || {});
    },
    addRule: function addRule() {
      var options = this.options ? this.options : {
        submitBtn: false,
        resetBtn: false
      };
      options.formData = subForm_extends({}, this.value || {});
      this.cacheRule = { rule: this.rule, options: options };
    },
    add$f: function add$f($f) {
      var _this = this;

      this.cacheRule.$f = $f;
      this.subForm();
      this.$nextTick(function () {
        $f.disabled(_this.disabled);
        _this.$emit('itemMounted', $f);
      });
    },
    subForm: function subForm() {
      this.$emit('fc.sub-form', this.cacheRule.$f);
    },
    emitEvent: function emitEvent(name) {
      for (var _len = arguments.length, args = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
        args[_key - 1] = arguments[_key];
      }

      this.$emit.apply(this, [name].concat(args));
    }
  },
  created: function created() {
    this.addRule();
  },
  render: function render() {
    var h = arguments[0];
    var _cacheRule = this.cacheRule,
        rule = _cacheRule.rule,
        options = _cacheRule.options;

    return h(FormCreate, {
      attrs: {
        on: {
          'update:value': this.formData,
          'emit-event': this.emitEvent,
          input: this.add$f
        },
        rule: rule,
        option: options, extendOption: true }
    });
  }
});
// CONCATENATED MODULE: ./packages/form-create/src/components/index.js





// import upload from './upload.vue';



/* harmony default export */ var components = __webpack_exports__["a"] = ([components_checkbox, components_frame, components_radio, components_select, components_tree, components_upload, group, subForm]);

/***/ }),
/* 79 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";

// EXTERNAL MODULE: ./packages/form-create/coreSrc/index.js + 31 modules
var coreSrc = __webpack_require__(24);

// CONCATENATED MODULE: ./packages/form-create/src/parsers/datePicker.js


var DEFAULT_FORMATS = {
  date: 'yyyy-MM-dd',
  month: 'yyyy-MM',
  datetime: 'yyyy-MM-dd HH:mm:ss',
  week: 'yyyywWW',
  timerange: 'HH:mm:ss',
  daterange: 'yyyy-MM-dd',
  monthrange: 'yyyy-MM',
  datetimerange: 'yyyy-MM-dd HH:mm:ss',
  year: 'yyyy'
};

var datePicker_name = 'datePicker';

/* harmony default export */ var datePicker = ({
  name: datePicker_name,
  maker: function () {
    return ['year', 'month', 'date', 'dates', 'week', 'datetime', 'datetimeRange', 'dateRange', 'monthRange'].reduce(function (initial, type) {
      initial[type] = Object(coreSrc["a" /* creatorFactory */])(datePicker_name, { type: type.toLowerCase() });
      return initial;
    }, {});
  }(),
  mergeProp: function mergeProp(ctx) {
    var props = ctx.prop.props;
    if (!props.valueFormat) {
      props.valueFormat = DEFAULT_FORMATS[props.type] || DEFAULT_FORMATS['date'];
    }
  }
});
// CONCATENATED MODULE: ./packages/form-create/src/parsers/hidden.js
var _maker;



var hidden_name = 'hidden';
/* harmony default export */ var parsers_hidden = ({
  name: hidden_name,
  maker: (_maker = {}, _maker[hidden_name] = function (field, value) {
    return Object(coreSrc["a" /* creatorFactory */])(hidden_name)('', field, value);
  }, _maker),
  render: function render() {
    return [];
  }
});
// CONCATENATED MODULE: ./packages/form-create/src/parsers/input.js


var input_name = 'input';
/* harmony default export */ var input = ({
  name: input_name,
  maker: function () {
    var maker = ['password', 'url', 'email', 'text', 'textarea'].reduce(function (maker, type) {
      maker[type] = Object(coreSrc["a" /* creatorFactory */])(input_name, { type: type });
      return maker;
    }, {});

    maker.idate = Object(coreSrc["a" /* creatorFactory */])(input_name, { type: 'date' });
    return maker;
  }(),
  mergeProp: function mergeProp(ctx) {
    var props = ctx.prop.props;

    if (props && props.autosize && props.autosize.minRows) {
      props.rows = props.autosize.minRows || 2;
    }
  }
});
// CONCATENATED MODULE: ./packages/form-create/src/parsers/slider.js
/* eslint-disable one-var */


var slider_name = 'slider';

/* harmony default export */ var slider = ({
  name: slider_name,
  maker: {
    sliderRange: Object(coreSrc["a" /* creatorFactory */])(slider_name, { range: true })
  },
  toFormValue: function toFormValue(value, ctx) {
    var isArr = Array.isArray(value),
        props = ctx.prop.props,
        min = props.min || 0,
        parseValue = void 0;
    if (props.range === true) {
      parseValue = isArr ? value : [min, parseFloat(value) || min];
    } else {
      parseValue = isArr ? parseFloat(value[0]) || min : parseFloat(value);
    }
    return parseValue;
  }
});
// CONCATENATED MODULE: ./packages/form-create/src/parsers/timePicker.js
/* eslint-disable no-return-assign */
// packages\form-create\coreSrc\index.js

var timePicker_name = 'timePicker';
/* harmony default export */ var timePicker = ({
  name: timePicker_name,
  maker: {
    time: Object(coreSrc["a" /* creatorFactory */])(timePicker_name, function (m) {
      return m.props.isRange = false;
    }),
    timeRange: Object(coreSrc["a" /* creatorFactory */])(timePicker_name, function (m) {
      return m.props.isRange = true;
    })
  },
  mergeProp: function mergeProp(ctx) {
    var props = ctx.prop.props;
    if (!props.valueFormat) {
      props.valueFormat = 'HH:mm:ss';
    }
  }
});
// CONCATENATED MODULE: ./packages/form-create/src/parsers/row.js
/* harmony default export */ var row = ({
  name: 'FcRow',
  render: function render(_, ctx) {
    return ctx.vNode.col({ props: { span: 24 } }, [ctx.vNode.row(ctx.prop, _)]);
  }
});
// EXTERNAL MODULE: ./packages/form-create/utils/toarray.js
var toarray = __webpack_require__(32);

// CONCATENATED MODULE: ./packages/form-create/src/parsers/select.js


var select_name = 'select';

/* harmony default export */ var parsers_select = ({
  name: select_name,
  toFormValue: function toFormValue(value, ctx) {
    if (ctx.prop.props.multiple && !Array.isArray(value)) {
      return Object(toarray["a" /* default */])(value);
    } else {
      return value;
    }
  }
});
// CONCATENATED MODULE: ./packages/form-create/src/parsers/index.js








/* harmony default export */ var parsers = __webpack_exports__["a"] = ([datePicker, parsers_hidden, input, slider, timePicker, row, parsers_select]);

/***/ }),
/* 80 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";

// UNUSED EXPORTS: isAttr

// CONCATENATED MODULE: ./packages/form-create/src/core/config.js
function getConfig() {
  return {
    form: {
      inline: false,
      labelPosition: 'right',
      labelWidth: '125px',
      disabled: false,
      size: undefined
    },
    row: {
      show: true,
      gutter: 0
    },
    submitBtn: {
      type: 'primary',
      loading: false,
      disabled: false,
      innerText: '提交',
      show: true,
      col: undefined,
      click: undefined
    },
    resetBtn: {
      type: 'default',
      loading: false,
      disabled: false,
      icon: 'el-icon-refresh',
      innerText: '重置',
      show: false,
      col: undefined,
      click: undefined
    }
  };
}
// EXTERNAL MODULE: ./packages/form-create/utils/mergeprops.js
var mergeprops = __webpack_require__(23);

// EXTERNAL MODULE: ./packages/form-create/utils/type.js
var type = __webpack_require__(5);

// EXTERNAL MODULE: ./packages/form-create/utils/tostring.js
var tostring = __webpack_require__(49);

// EXTERNAL MODULE: ./packages/form-create/utils/extend.js
var extend = __webpack_require__(7);

// CONCATENATED MODULE: ./packages/form-create/src/core/manager.js
var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };







function isTooltip(info) {
  return info.type === 'tooltip';
}

var upperCaseReg = /[A-Z]/;

function isAttr(name, value) {
  return !upperCaseReg.test(name) && (type["a" /* default */].String(value) || type["a" /* default */].Number(value));
}

function tidy(props, name) {
  if (!Object(type["b" /* hasProperty */])(props, name)) return;
  if (type["a" /* default */].String(props[name])) {
    var _props$name;

    props[name] = (_props$name = {}, _props$name[name] = props[name], _props$name.show = true, _props$name);
  }
}

function isFalse(val) {
  return val === false;
}

function tidyBool(opt, name) {
  if (Object(type["b" /* hasProperty */])(opt, name) && !type["a" /* default */].Object(opt[name])) {
    opt[name] = { show: !!opt[name] };
  }
}

/* harmony default export */ var manager = __webpack_exports__["a"] = ({
  validate: function validate(call) {
    this.form().validate(call);
  },
  validateField: function validateField(field, call) {
    this.form().validateField(field, call);
  },
  clearValidateState: function clearValidateState(ctx) {
    var fItem = this.vm.$refs[ctx.wrapRef];
    if (fItem) {
      fItem.validateMessage = '';
      fItem.validateState = '';
    }
  },
  tidyOptions: function tidyOptions(options) {
    ['submitBtn', 'resetBtn', 'row', 'info', 'wrap', 'col'].forEach(function (name) {
      tidyBool(options, name);
    });
    return options;
  },
  tidyRule: function tidyRule(_ref) {
    var prop = _ref.prop;

    tidy(prop, 'title');
    tidy(prop, 'info');
    return prop;
  },
  mergeProp: function mergeProp(ctx) {
    var props = ctx.prop.props;
    ctx.prop = Object(mergeprops["a" /* default */])([{
      attrs: Object.keys(props).reduce(function (initial, val) {
        if (isAttr(val, props[val])) {
          initial[val] = props[val];
        }
        return initial;
      }, {}),
      info: this.options.info || {},
      wrap: this.options.wrap || {},
      col: this.options.col || {}
    }, ctx.prop], {
      info: {
        trigger: 'hover',
        placement: 'top-start',
        icon: 'el-icon-warning'
      },
      title: {},
      col: { span: 24 },
      wrap: {}
    }, { normal: ['title', 'info', 'col', 'wrap'] });
  },
  getDefaultOptions: function getDefaultOptions() {
    return getConfig();
  },
  update: function update() {
    var form = this.options.form;
    this.rule = {
      props: _extends({}, form),
      nativeOn: {
        submit: function submit(e) {
          e.preventDefault();
        }
      },
      class: [form.className, form.class, 'form-create'],
      style: form.style,
      type: 'form'
    };
  },
  beforeRender: function beforeRender() {
    var key = this.key,
        ref = this.ref,
        $handle = this.$handle;

    Object(extend["a" /* default */])(this.rule, { key: key, ref: ref });
    Object(extend["a" /* default */])(this.rule.props, {
      model: $handle.formData,
      rules: $handle.validate()
    });
  },
  render: function render(children) {
    if (children.length) {
      children.push(this.makeFormBtn());
    }
    return this.$r(this.rule, isFalse(this.options.row.show) ? children : [this.makeRow(children)]);
  },
  makeWrap: function makeWrap(ctx, children) {
    var rule = ctx.prop;
    var uni = '' + this.key + ctx.key;
    var col = rule.col;
    var isTitle = this.isTitle(rule);
    var labelWidth = !col.labelWidth && !isTitle ? 0 : col.labelWidth;
    var _rule$props = this.rule.props,
        inline = _rule$props.inline,
        _col = _rule$props.col;

    var item = isFalse(rule.wrap.show) ? children : this.$r(Object(mergeprops["a" /* default */])([rule.wrap, {
      props: _extends({
        label: rule.title.title,
        labelWidth: labelWidth === void 0 ? labelWidth : Object(tostring["a" /* default */])(labelWidth)
      }, rule.wrap || {}, {
        prop: ctx.field,
        rules: rule.validate
      }),
      class: rule.className,
      key: uni + 'fi',
      ref: ctx.wrapRef,
      type: 'formItem'
    }]), [children, isTitle ? this.makeInfo(rule, uni) : null]);
    return inline === true || isFalse(_col) || isFalse(col.show) ? item : this.makeCol(rule, uni, [item]);
  },
  isTitle: function isTitle(rule) {
    var title = rule.title;
    return !(!title.title && !title.native || isFalse(title.show));
  },
  makeInfo: function makeInfo(rule, uni) {
    var _this = this;

    var titleProp = rule.title;
    var infoProp = rule.info;
    var isTip = isTooltip(infoProp);
    var children = [titleProp.title];
    var titleFn = function titleFn(pop) {
      return _this.$r(Object(mergeprops["a" /* default */])([titleProp, {
        props: titleProp,
        slot: titleProp.slot || (pop ? isTip ? 'default' : 'reference' : 'label'),
        key: uni + 'tit',
        type: titleProp.type || 'span'
      }]), children);
    };

    if (!isFalse(infoProp.show) && (infoProp.info || infoProp.native)) {
      if (infoProp.icon !== false) {
        children[infoProp.align !== 'left' ? 'unshift' : 'push'](this.$r({
          type: 'i',
          class: infoProp.icon === true ? 'el-icon-warning' : infoProp.icon,
          key: uni + 'i'
        }));
      }
      var prop = {
        type: infoProp.type || 'popover',
        props: _extends({}, infoProp),
        key: uni + 'pop',
        slot: 'label'
      };

      var field = 'content';
      if (infoProp.info && !Object(type["b" /* hasProperty */])(prop.props, field)) {
        prop.props[field] = infoProp.info;
      }

      return this.$r(Object(mergeprops["a" /* default */])([infoProp, prop]), [titleFn(true)]);
    }
    return titleFn();
  },
  makeCol: function makeCol(rule, uni, children) {
    var col = rule.col;
    return this.$r({
      class: col.class,
      type: 'col',
      props: col || { span: 24 },
      key: uni + 'col'
    }, children);
  },
  makeRow: function makeRow(children) {
    var row = this.options.row || {};
    return this.$r({
      type: 'row',
      props: row,
      class: row.class,
      key: this.key + 'row'
    }, children);
  },
  makeFormBtn: function makeFormBtn() {
    var vn = [];
    if (!isFalse(this.options.submitBtn.show)) {
      vn.push(this.makeSubmitBtn());
    }
    if (!isFalse(this.options.resetBtn.show)) {
      vn.push(this.makeResetBtn());
    }
    if (!vn.length) {
      return;
    }
    var item = this.$r({
      type: 'formItem',
      key: this.key + 'fb'
    }, vn);

    return this.rule.props.inline === true ? item : this.$r({
      type: 'col',
      props: { span: 24 },
      key: this.key + 'fc'
    }, [item]);
  },
  makeResetBtn: function makeResetBtn() {
    var _this2 = this;

    var resetBtn = this.options.resetBtn;
    return this.$r({
      type: 'button',
      props: resetBtn,
      style: { width: resetBtn.width },
      on: {
        click: function click() {
          var fApi = _this2.$handle.api;
          resetBtn.click ? resetBtn.click(fApi) : fApi.resetFields();
        }
      },
      key: this.key + 'b2'
    }, [resetBtn.innerText]);
  },
  makeSubmitBtn: function makeSubmitBtn() {
    var _this3 = this;

    var submitBtn = this.options.submitBtn;

    return this.$r({
      type: 'button',
      props: submitBtn,
      style: { width: submitBtn.width },
      on: {
        click: function click() {
          var fApi = _this3.$handle.api;
          submitBtn.click ? submitBtn.click(fApi) : fApi.submit();
        }
      },
      key: this.key + 'b1'
    }, [submitBtn.innerText]);
  }
});

/***/ }),
/* 81 */,
/* 82 */,
/* 83 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "maker", function() { return maker; });
/* harmony import */ var _src_core_index__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(75);


var FormCreate = Object(_src_core_index__WEBPACK_IMPORTED_MODULE_0__[/* default */ "a"])();

if (typeof window !== 'undefined') {
  window.formCreate = FormCreate;
  if (window.Vue) {
    FormCreate.install(window.Vue);
  }
}

var maker = FormCreate.maker;


/* harmony default export */ __webpack_exports__["default"] = (FormCreate);

/***/ }),
/* 84 */
/***/ (function(module, exports) {

// shim for using process in browser
var process = module.exports = {};

// cached from whatever global is present so that test runners that stub it
// don't break things.  But we need to wrap it in a try catch in case it is
// wrapped in strict mode code which doesn't define any globals.  It's inside a
// function because try/catches deoptimize in certain engines.

var cachedSetTimeout;
var cachedClearTimeout;

function defaultSetTimout() {
    throw new Error('setTimeout has not been defined');
}
function defaultClearTimeout () {
    throw new Error('clearTimeout has not been defined');
}
(function () {
    try {
        if (typeof setTimeout === 'function') {
            cachedSetTimeout = setTimeout;
        } else {
            cachedSetTimeout = defaultSetTimout;
        }
    } catch (e) {
        cachedSetTimeout = defaultSetTimout;
    }
    try {
        if (typeof clearTimeout === 'function') {
            cachedClearTimeout = clearTimeout;
        } else {
            cachedClearTimeout = defaultClearTimeout;
        }
    } catch (e) {
        cachedClearTimeout = defaultClearTimeout;
    }
} ())
function runTimeout(fun) {
    if (cachedSetTimeout === setTimeout) {
        //normal enviroments in sane situations
        return setTimeout(fun, 0);
    }
    // if setTimeout wasn't available but was latter defined
    if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {
        cachedSetTimeout = setTimeout;
        return setTimeout(fun, 0);
    }
    try {
        // when when somebody has screwed with setTimeout but no I.E. maddness
        return cachedSetTimeout(fun, 0);
    } catch(e){
        try {
            // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally
            return cachedSetTimeout.call(null, fun, 0);
        } catch(e){
            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error
            return cachedSetTimeout.call(this, fun, 0);
        }
    }


}
function runClearTimeout(marker) {
    if (cachedClearTimeout === clearTimeout) {
        //normal enviroments in sane situations
        return clearTimeout(marker);
    }
    // if clearTimeout wasn't available but was latter defined
    if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {
        cachedClearTimeout = clearTimeout;
        return clearTimeout(marker);
    }
    try {
        // when when somebody has screwed with setTimeout but no I.E. maddness
        return cachedClearTimeout(marker);
    } catch (e){
        try {
            // When we are in I.E. but the script has been evaled so I.E. doesn't  trust the global object when called normally
            return cachedClearTimeout.call(null, marker);
        } catch (e){
            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error.
            // Some versions of I.E. have different rules for clearTimeout vs setTimeout
            return cachedClearTimeout.call(this, marker);
        }
    }



}
var queue = [];
var draining = false;
var currentQueue;
var queueIndex = -1;

function cleanUpNextTick() {
    if (!draining || !currentQueue) {
        return;
    }
    draining = false;
    if (currentQueue.length) {
        queue = currentQueue.concat(queue);
    } else {
        queueIndex = -1;
    }
    if (queue.length) {
        drainQueue();
    }
}

function drainQueue() {
    if (draining) {
        return;
    }
    var timeout = runTimeout(cleanUpNextTick);
    draining = true;

    var len = queue.length;
    while(len) {
        currentQueue = queue;
        queue = [];
        while (++queueIndex < len) {
            if (currentQueue) {
                currentQueue[queueIndex].run();
            }
        }
        queueIndex = -1;
        len = queue.length;
    }
    currentQueue = null;
    draining = false;
    runClearTimeout(timeout);
}

process.nextTick = function (fun) {
    var args = new Array(arguments.length - 1);
    if (arguments.length > 1) {
        for (var i = 1; i < arguments.length; i++) {
            args[i - 1] = arguments[i];
        }
    }
    queue.push(new Item(fun, args));
    if (queue.length === 1 && !draining) {
        runTimeout(drainQueue);
    }
};

// v8 likes predictible objects
function Item(fun, array) {
    this.fun = fun;
    this.array = array;
}
Item.prototype.run = function () {
    this.fun.apply(null, this.array);
};
process.title = 'browser';
process.browser = true;
process.env = {};
process.argv = [];
process.version = ''; // empty string to avoid regexp issues
process.versions = {};

function noop() {}

process.on = noop;
process.addListener = noop;
process.once = noop;
process.off = noop;
process.removeListener = noop;
process.removeAllListeners = noop;
process.emit = noop;
process.prependListener = noop;
process.prependOnceListener = noop;

process.listeners = function (name) { return [] }

process.binding = function (name) {
    throw new Error('process.binding is not supported');
};

process.cwd = function () { return '/' };
process.chdir = function (dir) {
    throw new Error('process.chdir is not supported');
};
process.umask = function() { return 0; };


/***/ })
/******/ ]);